134 lines
3.6 KiB
TypeScript
134 lines
3.6 KiB
TypeScript
import * as path from 'path';
|
|
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.
|
|
*
|
|
* Renames the nested directory to a temp location, removes the dest dir,
|
|
* then renames the temp dir back as dest. Uses only rename operations
|
|
* which are atomic at the kernel level.
|
|
*
|
|
* 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__';
|
|
|
|
// Step 1: Clean up any leftover temp dir from a previous failed run
|
|
await FsHelpers.removeDirectory(tempPath);
|
|
|
|
// Step 2: Rename nested → temp
|
|
await FsHelpers.move(nestedPath, tempPath);
|
|
|
|
// Step 3: Remove dest dir (now contains only sibling folders)
|
|
await FsHelpers.removeDirectory(this.destDir);
|
|
|
|
// Step 4: Rename temp → dest
|
|
await FsHelpers.move(tempPath, this.destDir);
|
|
|
|
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();
|
|
}
|