@soundscript/soundscript 0.1.12 → 0.1.15

package/project-transform/src/build_package.js

@@ -0,0 +1,475 @@
+import { dirname, extname, join, relative } from './platform/path.js';
+import ts from 'typescript';
+import { createSoundStdlibCompilerHost } from './bundled/sound_stdlib.js';
+import { formatDiagnostics, hasErrorDiagnostics, toMergedDiagnostic, } from './checker/diagnostics.js';
+import { analyzeProject } from './checker/analyze_project.js';
+import { collectSoundscriptRootNames, getConfigFileParsingDiagnostics, loadConfig, } from './config.js';
+import { createBuiltinExpandedProgram } from './frontend/builtin_macro_support.js';
+import { MacroError } from './frontend/macro_errors.js';
+import { emitProjectedDeclarations, isSoundscriptSourceFile, toSourceFileName, } from './frontend/project_frontend.js';
+import { loadSoundScriptPackageInfo } from './soundscript_packages.js';
+import { copyFile, fileExistsSync, makeDirectory, readTextFileSync, removePath, writeTextFile, } from './platform/host.js';
+import { rewriteModuleSpecifiersForEmit, transpilePreparedSoundscriptModuleToEsm, transpileTypeScriptModuleToEsm, } from './runtime/transform.js';
+import { SOUNDSCRIPT_RUNTIME_PACKAGE_NAME } from './soundscript_runtime_specifiers.js';
+const DECLARATION_CAPTURE_OUT_DIR = '/__soundscript_build_types__';
+function createMacroDiagnostic(error) {
+    return {
+        source: 'cli',
+        code: error.code,
+        category: 'error',
+        message: error.message,
+        filePath: error.filePath,
+        line: error.line,
+        column: error.column,
+        endLine: error.endLine,
+        endColumn: error.endColumn,
+    };
+}
+function isPackageLocalSourceFile(fileName, packageRoot) {
+    return fileName.startsWith(`${packageRoot}/`) &&
+        !fileName.endsWith('.d.ts') &&
+        !fileName.includes('/node_modules/');
+}
+function toJsRelativePath(relativePath) {
+    const extension = extname(relativePath);
+    return extension.length > 0
+        ? `${relativePath.slice(0, -extension.length)}.js`
+        : `${relativePath}.js`;
+}
+function toDeclarationRelativePath(relativePath) {
+    const extension = extname(relativePath);
+    return extension.length > 0
+        ? `${relativePath.slice(0, -extension.length)}.d.ts`
+        : `${relativePath}.d.ts`;
+}
+function toEntryWrapperRelativePath(exportKey) {
+    return exportKey === '.' ? 'index' : exportKey.slice(2);
+}
+function renderBuildOutput(artifacts, projectPath) {
+    const artifactBaseDirectory = dirname(projectPath);
+    const renderedFiles = artifacts.emittedFiles
+        .map((filePath) => `  ${relative(artifactBaseDirectory, filePath)}`)
+        .join('\n');
+    return [
+        `Built package: ${relative(artifactBaseDirectory, artifacts.outDir)}`,
+        renderedFiles,
+        '',
+    ].join('\n');
+}
+function findNearestPackageJson(startDirectory) {
+    let currentDirectory = startDirectory;
+    while (true) {
+        const candidate = join(currentDirectory, 'package.json');
+        if (fileExistsSync(candidate)) {
+            return candidate;
+        }
+        const parentDirectory = dirname(currentDirectory);
+        if (parentDirectory === currentDirectory) {
+            return undefined;
+        }
+        currentDirectory = parentDirectory;
+    }
+}
+async function emptyDirectory(path) {
+    await removePath(path).catch(() => undefined);
+    await makeDirectory(path);
+}
+async function copyFileIfPresent(sourcePath, destinationPath) {
+    if (!fileExistsSync(sourcePath)) {
+        return false;
+    }
+    await makeDirectory(dirname(destinationPath));
+    await copyFile(sourcePath, destinationPath);
+    return true;
+}
+function relativeImportSpecifier(fromFilePath, toFilePath) {
+    const relativePath = relative(dirname(fromFilePath), toFilePath).replaceAll('\\', '/');
+    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+}
+function relativeTypeImportSpecifier(fromFilePath, toDeclarationPath) {
+    const specifier = relativeImportSpecifier(fromFilePath, toDeclarationPath);
+    return specifier.endsWith('.d.ts') ? specifier.slice(0, -5) : specifier;
+}
+function moduleHasDefaultExport(program, programFileName) {
+    const sourceFile = program.getSourceFile(programFileName);
+    if (!sourceFile) {
+        return false;
+    }
+    const checker = program.getTypeChecker();
+    const symbol = checker.getSymbolAtLocation(sourceFile);
+    if (!symbol) {
+        return false;
+    }
+    return checker.getExportsOfModule(symbol).some((exportSymbol) => exportSymbol.name === 'default');
+}
+function createEntryWrapperText(importSpecifier, hasDefaultExport) {
+    const lines = [`export * from '${importSpecifier}';`];
+    if (hasDefaultExport) {
+        lines.push(`export { default } from '${importSpecifier}';`);
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+function createPackageBuildProgram(options) {
+    const loadedConfig = loadConfig(options.projectPath, { target: options.target });
+    const soundscriptRootNames = collectSoundscriptRootNames(options.projectPath, loadedConfig);
+    return createBuiltinExpandedProgram({
+        baseHost: createSoundStdlibCompilerHost(loadedConfig.commandLine.options, dirname(options.projectPath)),
+        configFileParsingDiagnostics: getConfigFileParsingDiagnostics(loadedConfig.diagnostics, soundscriptRootNames),
+        options: {
+            ...loadedConfig.commandLine.options,
+            declaration: true,
+            emitDeclarationOnly: true,
+            noEmit: false,
+            outDir: DECLARATION_CAPTURE_OUT_DIR,
+            sourceMap: true,
+        },
+        projectReferences: loadedConfig.commandLine.projectReferences,
+        runtime: loadedConfig.runtime,
+        rootNames: [...new Set([...loadedConfig.commandLine.fileNames, ...soundscriptRootNames])],
+    });
+}
+function captureTypeScriptDeclarationOutputs(program) {
+    const outputs = new Map();
+    program.emit(undefined, (fileName, text) => {
+        outputs.set(fileName, text);
+    }, undefined, true);
+    return outputs;
+}
+async function writeGeneratedFile(filePath, text, emittedFiles) {
+    await makeDirectory(dirname(filePath));
+    await writeTextFile(filePath, text);
+    emittedFiles.push(filePath);
+}
+function parsePackageJsonRecord(packageJsonPath) {
+    return JSON.parse(readTextFileSync(packageJsonPath));
+}
+function collectInvalidSoundscriptExportDiagnostics(packageJsonPath, packageJson, packageInfo) {
+    const soundscript = packageJson.soundscript;
+    if (!soundscript || typeof soundscript !== 'object' || Array.isArray(soundscript)) {
+        return [];
+    }
+    const metadata = soundscript;
+    if (!metadata.exports || typeof metadata.exports !== 'object' || Array.isArray(metadata.exports)) {
+        return [];
+    }
+    const diagnostics = [];
+    const declaredExports = metadata.exports;
+    for (const [exportKey, rawEntry] of Object.entries(declaredExports)) {
+        if (!rawEntry || typeof rawEntry !== 'object' || Array.isArray(rawEntry)) {
+            diagnostics.push({
+                source: 'cli',
+                code: 'SOUNDSCRIPT_BUILD_INVALID_EXPORT',
+                category: 'error',
+                message: `soundscript.exports["${exportKey}"] must be an object with a valid "source" path.`,
+                hint: 'Use an object with a `source` field that points at an existing `.sts` file in the published package surface.',
+                filePath: packageJsonPath,
+                line: 1,
+                column: 1,
+                endLine: 1,
+                endColumn: 1,
+            });
+            continue;
+        }
+        const source = rawEntry.source;
+        if (typeof source !== 'string' || source.length === 0) {
+            diagnostics.push({
+                source: 'cli',
+                code: 'SOUNDSCRIPT_BUILD_INVALID_EXPORT',
+                category: 'error',
+                message: `soundscript.exports["${exportKey}"] must provide a string "source" path.`,
+                hint: 'Use an object with a `source` field that points at an existing `.sts` file in the published package surface.',
+                filePath: packageJsonPath,
+                line: 1,
+                column: 1,
+                endLine: 1,
+                endColumn: 1,
+            });
+            continue;
+        }
+        if (!packageInfo?.exports.has(exportKey)) {
+            diagnostics.push({
+                source: 'cli',
+                code: 'SOUNDSCRIPT_BUILD_INVALID_EXPORT',
+                category: 'error',
+                message: `soundscript.exports["${exportKey}"] points to a missing source file: ${source}`,
+                hint: 'Point each `soundscript.exports` entry at an existing `.sts` file that belongs to the published package surface.',
+                filePath: packageJsonPath,
+                line: 1,
+                column: 1,
+                endLine: 1,
+                endColumn: 1,
+            });
+        }
+    }
+    return diagnostics;
+}
+function buildDistPackageJson(originalPackageJson, packageInfo) {
+    const exportsRecord = {};
+    const soundscriptExports = {};
+    for (const [exportKey, sourceEntryPath] of packageInfo.exports.entries()) {
+        const relativeSourcePath = relative(packageInfo.packageRoot, sourceEntryPath).replaceAll('\\', '/');
+        const wrapperRelativePath = toEntryWrapperRelativePath(exportKey);
+        exportsRecord[exportKey] = {
+            import: `./esm/${wrapperRelativePath}.js`,
+            types: `./types/${wrapperRelativePath}.d.ts`,
+        };
+        soundscriptExports[exportKey] = {
+            source: `./soundscript/${relativeSourcePath}`,
+        };
+    }
+    if (packageInfo.legacySourceEntryPath && !packageInfo.exports.has('.')) {
+        const relativeSourcePath = relative(packageInfo.packageRoot, packageInfo.legacySourceEntryPath)
+            .replaceAll('\\', '/');
+        exportsRecord['.'] = {
+            import: './esm/index.js',
+            types: './types/index.d.ts',
+        };
+        soundscriptExports['.'] = {
+            source: `./soundscript/${relativeSourcePath}`,
+        };
+    }
+    const files = ['esm/**', 'types/**', 'soundscript/**'];
+    if (fileExistsSync(join(dirname(packageInfo.packageJsonPath), 'README.md'))) {
+        files.unshift('README.md');
+    }
+    if (fileExistsSync(join(dirname(packageInfo.packageJsonPath), 'LICENSE'))) {
+        files.unshift('LICENSE');
+    }
+    return {
+        ...(typeof originalPackageJson.name === 'string' ? { name: originalPackageJson.name } : {}),
+        ...(typeof originalPackageJson.version === 'string'
+            ? { version: originalPackageJson.version }
+            : {}),
+        ...(typeof originalPackageJson.license === 'string'
+            ? { license: originalPackageJson.license }
+            : {}),
+        type: 'module',
+        ...(typeof originalPackageJson.repository === 'object'
+            ? { repository: originalPackageJson.repository }
+            : {}),
+        ...(typeof originalPackageJson.homepage === 'string'
+            ? { homepage: originalPackageJson.homepage }
+            : {}),
+        ...(typeof originalPackageJson.bugs === 'object' ? { bugs: originalPackageJson.bugs } : {}),
+        ...(exportsRecord['.'] ? { types: './types/index.d.ts' } : {}),
+        exports: exportsRecord,
+        files,
+        ...(packageInfo.name === SOUNDSCRIPT_RUNTIME_PACKAGE_NAME ? {} : packageInfo.toolchain
+            ? {
+                peerDependencies: {
+                    [SOUNDSCRIPT_RUNTIME_PACKAGE_NAME]: packageInfo.toolchain,
+                },
+            }
+            : {}),
+        soundscript: {
+            ...(packageInfo.version !== undefined ? { version: packageInfo.version } : {}),
+            ...(packageInfo.toolchain ? { toolchain: packageInfo.toolchain } : {}),
+            exports: soundscriptExports,
+        },
+    };
+}
+export async function buildProject(options) {
+    const packageJsonPath = findNearestPackageJson(dirname(options.projectPath));
+    if (!packageJsonPath) {
+        const diagnostics = [{
+                source: 'cli',
+                code: 'SOUNDSCRIPT_BUILD_NO_PACKAGE_JSON',
+                category: 'error',
+                message: 'Could not find a package.json for soundscript build.',
+                hint: 'Add a package.json in the package root before running `soundscript build`, or use `soundscript check` for local app-only workflows.',
+                filePath: options.projectPath,
+                line: 1,
+                column: 1,
+                endLine: 1,
+                endColumn: 1,
+            }];
+        return {
+            diagnostics,
+            exitCode: 1,
+            output: formatDiagnostics(diagnostics, options.workingDirectory),
+        };
+    }
+    const packageJson = parsePackageJsonRecord(packageJsonPath);
+    const packageInfo = loadSoundScriptPackageInfo(packageJsonPath, ts.sys);
+    const invalidExportDiagnostics = collectInvalidSoundscriptExportDiagnostics(packageJsonPath, packageJson, packageInfo);
+    if (invalidExportDiagnostics.length > 0) {
+        return {
+            diagnostics: invalidExportDiagnostics,
+            exitCode: 1,
+            output: formatDiagnostics(invalidExportDiagnostics, options.workingDirectory),
+        };
+    }
+    if (!packageInfo || (packageInfo.exports.size === 0 && !packageInfo.legacySourceEntryPath)) {
+        const diagnostics = [{
+                source: 'cli',
+                code: 'SOUNDSCRIPT_BUILD_NO_EXPORTS',
+                category: 'error',
+                message: 'package.json is missing soundscript.exports metadata for soundscript build.',
+                hint: 'Add `package.json#soundscript.exports` entries for the published `.sts` surface, or use `soundscript check` / runtime wrappers for local app workflows.',
+                filePath: packageJsonPath,
+                line: 1,
+                column: 1,
+                endLine: 1,
+                endColumn: 1,
+            }];
+        return {
+            diagnostics,
+            exitCode: 1,
+            output: formatDiagnostics(diagnostics, options.workingDirectory),
+        };
+    }
+    const analysis = analyzeProject({
+        projectPath: options.projectPath,
+        target: options.target,
+        workingDirectory: options.workingDirectory,
+    });
+    if (hasErrorDiagnostics(analysis.diagnostics)) {
+        return {
+            diagnostics: analysis.diagnostics,
+            exitCode: 1,
+            output: formatDiagnostics(analysis.diagnostics, options.workingDirectory),
+        };
+    }
+    const builtProgram = createPackageBuildProgram(options);
+    try {
+        const diagnostics = [
+            ...builtProgram.frontendDiagnostics(),
+            ...ts.getPreEmitDiagnostics(builtProgram.program).map(toMergedDiagnostic),
+        ];
+        if (hasErrorDiagnostics(diagnostics)) {
+            return {
+                diagnostics,
+                exitCode: 1,
+                output: formatDiagnostics(diagnostics, options.workingDirectory),
+            };
+        }
+        try {
+            void builtProgram.program.getTypeChecker();
+        }
+        catch (error) {
+            const merged = error instanceof MacroError ? [createMacroDiagnostic(error)] : [];
+            return {
+                diagnostics: merged,
+                exitCode: 1,
+                output: error instanceof MacroError
+                    ? formatDiagnostics(merged, options.workingDirectory)
+                    : String(error),
+            };
+        }
+        await emptyDirectory(options.outDir);
+        const emittedFiles = [];
+        const typeOutputs = captureTypeScriptDeclarationOutputs(builtProgram.program);
+        const projectedDeclarations = emitProjectedDeclarations(builtProgram.analysisPreparedProgram);
+        const packageRoot = packageInfo.packageRoot;
+        for (const sourceFile of builtProgram.program.getSourceFiles()) {
+            if (sourceFile.isDeclarationFile) {
+                continue;
+            }
+            const sourceFileName = toSourceFileName(sourceFile.fileName);
+            if (!isPackageLocalSourceFile(sourceFileName, packageRoot)) {
+                continue;
+            }
+            const relativeSourcePath = relative(packageRoot, sourceFileName).replaceAll('\\', '/');
+            const outputJsRelativePath = toJsRelativePath(relativeSourcePath);
+            const outputJsPath = join(options.outDir, 'esm', outputJsRelativePath);
+            const outputMapPath = `${outputJsPath}.map`;
+            const sourceMapComment = `//# sourceMappingURL=${relative(dirname(outputJsPath), outputMapPath).replaceAll('\\', '/')}`;
+            const artifact = isSoundscriptSourceFile(sourceFileName)
+                ? (() => {
+                    const preparedFile = builtProgram.diagnosticPreparedFiles.get(sourceFileName) ??
+                        builtProgram.analysisPreparedProgram.preparedHost.getPreparedSourceFile(sourceFileName);
+                    if (!preparedFile) {
+                        throw new Error(`Missing prepared source file for ${sourceFileName}.`);
+                    }
+                    return transpilePreparedSoundscriptModuleToEsm(sourceFileName, outputJsPath, preparedFile, {
+                        module: ts.ModuleKind.ES2022,
+                        target: ts.ScriptTarget.ES2022,
+                        valueProgram: builtProgram.program,
+                    });
+                })()
+                : transpileTypeScriptModuleToEsm(sourceFileName, outputJsPath, sourceFile.text, {
+                    module: ts.ModuleKind.ES2022,
+                    target: ts.ScriptTarget.ES2022,
+                });
+            await writeGeneratedFile(outputJsPath, `${artifact.code}\n${sourceMapComment}\n`, emittedFiles);
+            await writeGeneratedFile(outputMapPath, artifact.mapText, emittedFiles);
+        }
+        for (const [sourceFileName, declarationText] of projectedDeclarations.entries()) {
+            if (!isPackageLocalSourceFile(sourceFileName, packageRoot)) {
+                continue;
+            }
+            const relativeSourcePath = relative(packageRoot, sourceFileName).replaceAll('\\', '/');
+            const declarationPath = join(options.outDir, 'types', toDeclarationRelativePath(relativeSourcePath));
+            await writeGeneratedFile(declarationPath, rewriteModuleSpecifiersForEmit(declarationText, declarationPath), emittedFiles);
+        }
+        for (const [outputPath, declarationText] of typeOutputs.entries()) {
+            if (!outputPath.startsWith(`${DECLARATION_CAPTURE_OUT_DIR}/`) ||
+                outputPath.endsWith('.sts.d.ts')) {
+                continue;
+            }
+            const relativeOutputPath = relative(DECLARATION_CAPTURE_OUT_DIR, outputPath).replaceAll('\\', '/');
+            const destinationPath = join(options.outDir, 'types', relativeOutputPath);
+            await writeGeneratedFile(destinationPath, rewriteModuleSpecifiersForEmit(declarationText, destinationPath), emittedFiles);
+        }
+        const copiedSourceFiles = new Set();
+        for (const sourceFile of builtProgram.program.getSourceFiles()) {
+            if (sourceFile.isDeclarationFile) {
+                continue;
+            }
+            const sourceFileName = toSourceFileName(sourceFile.fileName);
+            if (!isPackageLocalSourceFile(sourceFileName, packageRoot) ||
+                copiedSourceFiles.has(sourceFileName)) {
+                continue;
+            }
+            copiedSourceFiles.add(sourceFileName);
+            const relativeSourcePath = relative(packageRoot, sourceFileName).replaceAll('\\', '/');
+            const destinationPath = join(options.outDir, 'soundscript', relativeSourcePath);
+            await makeDirectory(dirname(destinationPath));
+            await copyFile(sourceFileName, destinationPath);
+            emittedFiles.push(destinationPath);
+        }
+        const sourceEntries = packageInfo.exports.size > 0
+            ? [...packageInfo.exports.entries()]
+            : packageInfo.legacySourceEntryPath
+                ? [['.', packageInfo.legacySourceEntryPath]]
+                : [];
+        for (const [exportKey, sourceEntryPath] of sourceEntries) {
+            const relativeSourcePath = relative(packageRoot, sourceEntryPath).replaceAll('\\', '/');
+            const wrapperRelativePath = toEntryWrapperRelativePath(exportKey);
+            const sourceJsPath = join(options.outDir, 'esm', toJsRelativePath(relativeSourcePath));
+            const wrapperJsPath = join(options.outDir, 'esm', `${wrapperRelativePath}.js`);
+            const wrapperTypesPath = join(options.outDir, 'types', `${wrapperRelativePath}.d.ts`);
+            const programFileName = isSoundscriptSourceFile(sourceEntryPath)
+                ? builtProgram.preparedProgram.toProgramFileName(sourceEntryPath)
+                : sourceEntryPath;
+            const hasDefaultExport = moduleHasDefaultExport(builtProgram.program, programFileName);
+            const jsImportSpecifier = relativeImportSpecifier(wrapperJsPath, sourceJsPath);
+            const typesImportSpecifier = relativeTypeImportSpecifier(wrapperTypesPath, join(options.outDir, 'types', toDeclarationRelativePath(relativeSourcePath)));
+            await writeGeneratedFile(wrapperJsPath, createEntryWrapperText(jsImportSpecifier, hasDefaultExport), emittedFiles);
+            await writeGeneratedFile(wrapperTypesPath, createEntryWrapperText(typesImportSpecifier, hasDefaultExport), emittedFiles);
+        }
+        await copyFileIfPresent(join(packageRoot, 'README.md'), join(options.outDir, 'README.md'));
+        await copyFileIfPresent(join(packageRoot, 'LICENSE'), join(options.outDir, 'LICENSE'));
+        const distPackageJson = buildDistPackageJson(packageJson, packageInfo);
+        const distPackageJsonPath = join(options.outDir, 'package.json');
+        await writeGeneratedFile(distPackageJsonPath, `${JSON.stringify(distPackageJson, null, 2)}\n`, emittedFiles);
+        return {
+            artifacts: {
+                emittedFiles,
+                outDir: options.outDir,
+                packageJsonPath: distPackageJsonPath,
+            },
+            diagnostics: [],
+            exitCode: 0,
+            output: renderBuildOutput({
+                emittedFiles,
+                outDir: options.outDir,
+                packageJsonPath: distPackageJsonPath,
+            }, options.projectPath),
+        };
+    }
+    finally {
+        builtProgram.dispose();
+    }
+}