131 lines
3.7 KiB
TypeScript
131 lines
3.7 KiB
TypeScript
import * as path from 'path';
|
|
import { execSync } from 'child_process';
|
|
import { TsPublishConfig } from '../mod_config/index.js';
|
|
import { FsHelpers } from '../mod_fs/index.js';
|
|
|
|
/**
|
|
* TsUnpacker handles flattening of nested TypeScript output directories.
|
|
*
|
|
* When TypeScript compiles files that import from sibling directories,
|
|
* it creates a nested structure like:
|
|
* dist_ts_core/ts_core/index.js
|
|
* dist_ts_core/ts_shared/helper.js
|
|
*
|
|
* This class flattens it to:
|
|
* dist_ts_core/index.js
|
|
*/
|
|
export class TsUnpacker {
|
|
private sourceFolderName: string;
|
|
private destDir: string;
|
|
private cwd: string;
|
|
private config: TsPublishConfig;
|
|
|
|
constructor(sourceFolderName: string, destDir: string, cwd: string = process.cwd()) {
|
|
this.sourceFolderName = sourceFolderName;
|
|
this.destDir = destDir;
|
|
this.cwd = cwd;
|
|
this.config = new TsPublishConfig(path.join(cwd, sourceFolderName));
|
|
}
|
|
|
|
/**
|
|
* Create an unpacker from a glob pattern
|
|
* './ts_core/**\/*.ts' → sourceFolderName = 'ts_core'
|
|
*/
|
|
public static fromGlobPattern(
|
|
sourcePattern: string,
|
|
destDir: string,
|
|
cwd: string = process.cwd()
|
|
): TsUnpacker | null {
|
|
const sourceFolderName = FsHelpers.extractSourceFolder(sourcePattern);
|
|
if (!sourceFolderName) {
|
|
return null;
|
|
}
|
|
return new TsUnpacker(sourceFolderName, destDir, cwd);
|
|
}
|
|
|
|
/**
|
|
* Get the source folder name
|
|
*/
|
|
public getSourceFolderName(): string {
|
|
return this.sourceFolderName;
|
|
}
|
|
|
|
/**
|
|
* Get the destination directory
|
|
*/
|
|
public getDestDir(): string {
|
|
return this.destDir;
|
|
}
|
|
|
|
/**
|
|
* Check if unpacking should be performed based on tspublish.json config
|
|
* Default is true if not specified
|
|
*/
|
|
public async shouldUnpack(): Promise<boolean> {
|
|
return this.config.shouldUnpack;
|
|
}
|
|
|
|
/**
|
|
* Check if nested structure exists in the destination directory
|
|
*/
|
|
public async detectNesting(): Promise<boolean> {
|
|
const nestedPath = path.join(this.destDir, this.sourceFolderName);
|
|
return FsHelpers.directoryExists(nestedPath);
|
|
}
|
|
|
|
/**
|
|
* Get the path to the nested directory
|
|
*/
|
|
public getNestedPath(): string {
|
|
return path.join(this.destDir, this.sourceFolderName);
|
|
}
|
|
|
|
/**
|
|
* Perform the unpack operation - flatten nested output directories.
|
|
*
|
|
* Uses shell commands (mv, rm) via execSync for reliability. Node.js async
|
|
* fs operations (rename, rm) can race on XFS filesystems where metadata
|
|
* commits are delayed, causing ENOENT or partial directory listings.
|
|
* Shell commands execute as direct syscalls without libuv's async layer.
|
|
*
|
|
* Returns true if unpacking was performed, false if skipped.
|
|
*/
|
|
public async unpack(): Promise<boolean> {
|
|
if (!(await this.shouldUnpack())) {
|
|
return false;
|
|
}
|
|
|
|
if (!(await this.detectNesting())) {
|
|
return false;
|
|
}
|
|
|
|
const nestedPath = this.getNestedPath();
|
|
const tempPath = this.destDir + '.__unpack_temp__';
|
|
|
|
// Use shell commands for atomic, sequential filesystem operations.
|
|
// This avoids race conditions between Node.js async fs operations on XFS.
|
|
execSync(`rm -rf "${tempPath}"`, { stdio: 'ignore' });
|
|
execSync(`mv "${nestedPath}" "${tempPath}"`, { stdio: 'ignore' });
|
|
execSync(`rm -rf "${this.destDir}"`, { stdio: 'ignore' });
|
|
execSync(`mv "${tempPath}" "${this.destDir}"`, { stdio: 'ignore' });
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Convenience function to perform unpack operation
|
|
* Can be used directly without instantiating the class
|
|
*/
|
|
export async function performUnpack(
|
|
sourcePattern: string,
|
|
destDir: string,
|
|
cwd: string = process.cwd()
|
|
): Promise<boolean> {
|
|
const unpacker = TsUnpacker.fromGlobPattern(sourcePattern, destDir, cwd);
|
|
if (!unpacker) {
|
|
return false;
|
|
}
|
|
return unpacker.unpack();
|
|
}
|