@soundscript/soundscript 0.1.12 → 0.1.15

package/project-transform/src/runtime/on_demand.ts

@@ -0,0 +1,305 @@
+import ts from 'typescript';
+
+import { createSoundStdlibCompilerHost } from '../bundled/sound_stdlib.ts';
+import {
+  collectSoundscriptRootNames,
+  getConfigFileParsingDiagnostics,
+  loadConfig,
+} from '../config.ts';
+import { dirname, join } from '../platform/path.ts';
+import { createBuiltinExpandedProgram } from '../frontend/builtin_macro_support.ts';
+import { isSoundscriptSourceFile, toSourceFileName } from '../frontend/project_frontend.ts';
+import { resolveSoundScriptAwareModule } from '../soundscript_packages.ts';
+import { type RuntimeTransformArtifact, transpileTypeScriptModuleToEsm } from './transform.ts';
+
+const PROJECT_CONFIG_CANDIDATES = ['tsconfig.soundscript.json', 'tsconfig.json'] as const;
+const LOCAL_CODE_EXTENSIONS = ['.sts', '.ts', '.tsx', '.mts', '.cts', '.jsx'] as const;
+
+interface TransformProjectContext {
+  readonly compilerOptions: ts.CompilerOptions;
+  readonly projectPath: string;
+}
+
+export interface OnDemandTransformResult extends RuntimeTransformArtifact {
+  projectPath: string;
+}
+
+export interface OnDemandTransformer {
+  resolveImportSpecifier(specifier: string, importer: string): string | undefined;
+  shouldTransformFile(fileName: string): boolean;
+  transformModule(fileName: string): Promise<OnDemandTransformResult>;
+}
+
+export interface SyncOnDemandTransformer extends OnDemandTransformer {
+  transformModuleSync(fileName: string): OnDemandTransformResult;
+}
+
+export interface OnDemandTransformerOptions {
+  projectPath?: string;
+  workingDirectory?: string;
+}
+
+function fileExists(path: string): boolean {
+  return ts.sys.fileExists(path);
+}
+
+function directoryExists(path: string): boolean {
+  return ts.sys.directoryExists?.(path) === true;
+}
+
+function isRelativeOrAbsoluteSpecifier(specifier: string): boolean {
+  return specifier.startsWith('./') || specifier.startsWith('../') || specifier.startsWith('/');
+}
+
+function isTypeScriptLikeFile(fileName: string): boolean {
+  const lowered = fileName.toLowerCase();
+  return (
+    lowered.endsWith('.ts') ||
+    lowered.endsWith('.tsx') ||
+    lowered.endsWith('.mts') ||
+    lowered.endsWith('.cts') ||
+    lowered.endsWith('.jsx')
+  ) && !(
+    lowered.endsWith('.d.ts') ||
+    lowered.endsWith('.d.mts') ||
+    lowered.endsWith('.d.cts')
+  );
+}
+
+function isTransformableRuntimeFile(fileName: string): boolean {
+  return isSoundscriptSourceFile(fileName) || isTypeScriptLikeFile(fileName);
+}
+
+function resolvePathWithExtensions(basePath: string): string | undefined {
+  for (const extension of LOCAL_CODE_EXTENSIONS) {
+    const candidate = `${basePath}${extension}`;
+    if (fileExists(candidate)) {
+      return candidate;
+    }
+  }
+  return undefined;
+}
+
+function resolveLocalDependency(containingFileName: string, specifier: string): string | undefined {
+  if (!isRelativeOrAbsoluteSpecifier(specifier)) {
+    return undefined;
+  }
+
+  const containingDirectory = dirname(containingFileName);
+  const candidateBase = specifier.startsWith('/')
+    ? specifier
+    : join(containingDirectory, specifier);
+  if (fileExists(candidateBase)) {
+    return candidateBase;
+  }
+
+  const directMatch = resolvePathWithExtensions(candidateBase);
+  if (directMatch) {
+    return directMatch;
+  }
+
+  if (directoryExists(candidateBase)) {
+    const indexMatch = resolvePathWithExtensions(join(candidateBase, 'index'));
+    if (indexMatch) {
+      return indexMatch;
+    }
+  }
+
+  return undefined;
+}
+
+function findNearestProjectPath(startPath: string): string | undefined {
+  const initialDirectory = fileExists(startPath) ? dirname(startPath) : startPath;
+  let currentDirectory = initialDirectory;
+
+  while (true) {
+    for (const candidate of PROJECT_CONFIG_CANDIDATES) {
+      const projectPath = join(currentDirectory, candidate);
+      if (fileExists(projectPath)) {
+        return projectPath;
+      }
+    }
+
+    const parentDirectory = dirname(currentDirectory);
+    if (parentDirectory === currentDirectory) {
+      return undefined;
+    }
+    currentDirectory = parentDirectory;
+  }
+}
+
+function createExpandedProgram(
+  projectPath: string,
+  extraRootNames: readonly string[] = [],
+) {
+  const loadedConfig = loadConfig(projectPath);
+  const soundscriptRootNames = collectSoundscriptRootNames(projectPath, loadedConfig);
+  return createBuiltinExpandedProgram({
+    baseHost: createSoundStdlibCompilerHost(
+      loadedConfig.commandLine.options,
+      dirname(projectPath),
+    ),
+    configFileParsingDiagnostics: getConfigFileParsingDiagnostics(
+      loadedConfig.diagnostics,
+      soundscriptRootNames,
+    ),
+    options: loadedConfig.commandLine.options,
+    projectReferences: loadedConfig.commandLine.projectReferences,
+    rootNames: [
+      ...new Set([
+        ...loadedConfig.commandLine.fileNames,
+        ...soundscriptRootNames,
+        ...extraRootNames,
+      ]),
+    ],
+  });
+}
+
+function getProjectContext(
+  fileName: string,
+  explicitProjectPath: string | undefined,
+): TransformProjectContext | undefined {
+  const projectPath = explicitProjectPath ?? findNearestProjectPath(fileName);
+  if (!projectPath) {
+    return undefined;
+  }
+
+  const loadedConfig = loadConfig(projectPath);
+  return {
+    compilerOptions: loadedConfig.commandLine.options,
+    projectPath,
+  };
+}
+
+function getExpandedProgramForSourceFile(
+  sourceFileName: string,
+  explicitProjectPath: string | undefined,
+): { expandedProgram: ReturnType<typeof createExpandedProgram>; projectPath: string } {
+  const projectPath = explicitProjectPath ?? findNearestProjectPath(sourceFileName);
+  if (!projectPath) {
+    throw new Error(
+      `Could not find a tsconfig.soundscript.json or tsconfig.json for ${sourceFileName}.`,
+    );
+  }
+
+  const expandedProgram = createExpandedProgram(projectPath, [sourceFileName]);
+  const programFileName = expandedProgram.preparedProgram.toProgramFileName(sourceFileName);
+  const sourceFile = expandedProgram.program.getSourceFile(programFileName);
+  if (!sourceFile) {
+    throw new Error(`Missing expanded source file for ${sourceFileName}.`);
+  }
+
+  return { expandedProgram, projectPath };
+}
+
+export function createOnDemandTransformer(
+  options: OnDemandTransformerOptions = {},
+): SyncOnDemandTransformer {
+  const typeScriptCache = new Map<string, OnDemandTransformResult>();
+
+  function transformModuleSync(fileName: string): OnDemandTransformResult {
+    if (isSoundscriptSourceFile(fileName)) {
+      const { expandedProgram, projectPath } = getExpandedProgramForSourceFile(
+        fileName,
+        options.projectPath,
+      );
+      try {
+        const programFileName = expandedProgram.preparedProgram.toProgramFileName(fileName);
+        const sourceFile = expandedProgram.program.getSourceFile(programFileName);
+        if (!sourceFile) {
+          throw new Error(`Missing expanded source file for ${fileName}.`);
+        }
+        const artifact = transpileTypeScriptModuleToEsm(
+          fileName,
+          `${fileName}.js`,
+          ts.createPrinter().printFile(sourceFile),
+          {
+            module: ts.ModuleKind.ES2022,
+            moduleSpecifierMode: 'preserve',
+            target: ts.ScriptTarget.ES2022,
+          },
+        );
+        return {
+          ...artifact,
+          projectPath,
+        };
+      } finally {
+        expandedProgram.dispose();
+      }
+    }
+
+    if (!isTypeScriptLikeFile(fileName)) {
+      throw new Error(`Only local .sts/.ts sources can be transformed on demand: ${fileName}`);
+    }
+
+    const sourceText = ts.sys.readFile(fileName);
+    if (sourceText === undefined) {
+      throw new Error(`Could not read source file ${fileName}.`);
+    }
+
+    const projectPath = getProjectContext(fileName, options.projectPath)?.projectPath ??
+      options.projectPath ??
+      findNearestProjectPath(fileName) ??
+      (options.workingDirectory ? join(options.workingDirectory, 'tsconfig.json') : fileName);
+    const sourceHash = ts.sys.createHash?.(sourceText) ?? sourceText;
+    const cacheKey = `${projectPath}\u0000${fileName}\u0000${sourceHash}`;
+    const cached = typeScriptCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    const artifact = transpileTypeScriptModuleToEsm(
+      fileName,
+      `${fileName}.js`,
+      sourceText,
+      {
+        module: ts.ModuleKind.ES2022,
+        moduleSpecifierMode: 'preserve',
+        target: ts.ScriptTarget.ES2022,
+      },
+    );
+    const result = {
+      ...artifact,
+      projectPath,
+    };
+    typeScriptCache.set(cacheKey, result);
+    return result;
+  }
+
+  return {
+    resolveImportSpecifier(specifier: string, importer: string): string | undefined {
+      const localResolved = resolveLocalDependency(importer, specifier);
+      if (localResolved) {
+        return localResolved;
+      }
+
+      if (isRelativeOrAbsoluteSpecifier(specifier)) {
+        return undefined;
+      }
+
+      const projectContext = getProjectContext(importer, options.projectPath);
+      if (!projectContext) {
+        return undefined;
+      }
+
+      const resolved = resolveSoundScriptAwareModule(
+        specifier,
+        importer,
+        projectContext.compilerOptions,
+        ts.sys,
+      );
+      return resolved && isTransformableRuntimeFile(resolved.resolvedFileName)
+        ? toSourceFileName(resolved.resolvedFileName)
+        : undefined;
+    },
+
+    shouldTransformFile(fileName: string): boolean {
+      return isTransformableRuntimeFile(fileName);
+    },
+
+    transformModule(fileName: string): Promise<OnDemandTransformResult> {
+      return Promise.resolve(transformModuleSync(fileName));
+    },
+    transformModuleSync,
+  };
+}

package/project-transform/src/runtime/source_maps.js

@@ -0,0 +1,205 @@
+import { mapProgramPositionToSource } from '../frontend/project_frontend.js';
+const BASE64_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const BASE64_LOOKUP = new Map([...BASE64_ALPHABET].map((character, index) => [character, index]));
+function toVlqSigned(value) {
+    return value < 0 ? ((-value) << 1) + 1 : value << 1;
+}
+function fromVlqSigned(value) {
+    const isNegative = (value & 1) === 1;
+    const shifted = value >> 1;
+    return isNegative ? -shifted : shifted;
+}
+function encodeVlqValue(value) {
+    let remaining = toVlqSigned(value);
+    let output = '';
+    do {
+        let digit = remaining & 31;
+        remaining >>= 5;
+        if (remaining > 0) {
+            digit |= 32;
+        }
+        output += BASE64_ALPHABET[digit];
+    } while (remaining > 0);
+    return output;
+}
+function decodeVlqValue(text, startIndex) {
+    let index = startIndex;
+    let shift = 0;
+    let value = 0;
+    while (index < text.length) {
+        const digit = BASE64_LOOKUP.get(text[index]);
+        if (digit === undefined) {
+            throw new Error(`Invalid source-map VLQ character ${JSON.stringify(text[index])}.`);
+        }
+        value += (digit & 31) << shift;
+        index += 1;
+        if ((digit & 32) === 0) {
+            return { nextIndex: index, value: fromVlqSigned(value) };
+        }
+        shift += 5;
+    }
+    throw new Error('Unterminated source-map VLQ segment.');
+}
+function decodeMappings(mappings) {
+    if (mappings.length === 0) {
+        return [[]];
+    }
+    const lines = mappings.split(';');
+    const decoded = [];
+    let previousSourceIndex = 0;
+    let previousOriginalLine = 0;
+    let previousOriginalColumn = 0;
+    let previousNameIndex = 0;
+    for (const line of lines) {
+        const segments = [];
+        let previousGeneratedColumn = 0;
+        if (line.length > 0) {
+            for (const rawSegment of line.split(',')) {
+                if (rawSegment.length === 0) {
+                    continue;
+                }
+                let cursor = 0;
+                const generatedColumnResult = decodeVlqValue(rawSegment, cursor);
+                cursor = generatedColumnResult.nextIndex;
+                previousGeneratedColumn += generatedColumnResult.value;
+                const segment = {
+                    generatedColumn: previousGeneratedColumn,
+                };
+                if (cursor < rawSegment.length) {
+                    const sourceIndexResult = decodeVlqValue(rawSegment, cursor);
+                    cursor = sourceIndexResult.nextIndex;
+                    previousSourceIndex += sourceIndexResult.value;
+                    segment.sourceIndex = previousSourceIndex;
+                    const originalLineResult = decodeVlqValue(rawSegment, cursor);
+                    cursor = originalLineResult.nextIndex;
+                    previousOriginalLine += originalLineResult.value;
+                    segment.originalLine = previousOriginalLine;
+                    const originalColumnResult = decodeVlqValue(rawSegment, cursor);
+                    cursor = originalColumnResult.nextIndex;
+                    previousOriginalColumn += originalColumnResult.value;
+                    segment.originalColumn = previousOriginalColumn;
+                    if (cursor < rawSegment.length) {
+                        const nameIndexResult = decodeVlqValue(rawSegment, cursor);
+                        previousNameIndex += nameIndexResult.value;
+                        segment.nameIndex = previousNameIndex;
+                    }
+                }
+                segments.push(segment);
+            }
+        }
+        decoded.push(segments);
+    }
+    return decoded;
+}
+function encodeMappings(lines) {
+    let previousSourceIndex = 0;
+    let previousOriginalLine = 0;
+    let previousOriginalColumn = 0;
+    let previousNameIndex = 0;
+    return lines.map((segments) => {
+        let previousGeneratedColumn = 0;
+        return segments.map((segment) => {
+            let encoded = encodeVlqValue(segment.generatedColumn - previousGeneratedColumn);
+            previousGeneratedColumn = segment.generatedColumn;
+            if (segment.sourceIndex !== undefined && segment.originalLine !== undefined &&
+                segment.originalColumn !== undefined) {
+                encoded += encodeVlqValue(segment.sourceIndex - previousSourceIndex);
+                previousSourceIndex = segment.sourceIndex;
+                encoded += encodeVlqValue(segment.originalLine - previousOriginalLine);
+                previousOriginalLine = segment.originalLine;
+                encoded += encodeVlqValue(segment.originalColumn - previousOriginalColumn);
+                previousOriginalColumn = segment.originalColumn;
+                if (segment.nameIndex !== undefined) {
+                    encoded += encodeVlqValue(segment.nameIndex - previousNameIndex);
+                    previousNameIndex = segment.nameIndex;
+                }
+            }
+            return encoded;
+        }).join(',');
+    }).join(';');
+}
+function computeLineStarts(text) {
+    const starts = [0];
+    for (let index = 0; index < text.length; index += 1) {
+        if (text[index] === '\n') {
+            starts.push(index + 1);
+        }
+    }
+    return starts;
+}
+function positionForLineAndColumn(lineStarts, line, column) {
+    const lineStart = lineStarts[line] ?? lineStarts[lineStarts.length - 1] ?? 0;
+    return lineStart + column;
+}
+function lineAndColumnForPosition(lineStarts, position) {
+    let low = 0;
+    let high = lineStarts.length - 1;
+    while (low <= high) {
+        const mid = (low + high) >> 1;
+        const lineStart = lineStarts[mid];
+        const nextLineStart = lineStarts[mid + 1] ?? Number.POSITIVE_INFINITY;
+        if (position < lineStart) {
+            high = mid - 1;
+            continue;
+        }
+        if (position >= nextLineStart) {
+            low = mid + 1;
+            continue;
+        }
+        return {
+            line: mid,
+            column: position - lineStart,
+        };
+    }
+    const fallbackLine = Math.max(0, lineStarts.length - 1);
+    return {
+        line: fallbackLine,
+        column: Math.max(0, position - (lineStarts[fallbackLine] ?? 0)),
+    };
+}
+function stripSourceMappingUrl(code) {
+    return code.replace(/\n\/\/# sourceMappingURL=.*$/u, '');
+}
+export function composeTranspiledSourceMapToOriginal(code, emittedSourceMapText, preparedFile, sourcePath) {
+    const emittedSourceMap = JSON.parse(emittedSourceMapText);
+    const decodedMappings = decodeMappings(emittedSourceMap.mappings);
+    const rewrittenLineStarts = computeLineStarts(preparedFile.rewrittenText);
+    const originalLineStarts = computeLineStarts(preparedFile.originalText);
+    const remappedSegments = decodedMappings.map((line) => line.map((segment) => {
+        if (segment.sourceIndex === undefined || segment.originalLine === undefined ||
+            segment.originalColumn === undefined) {
+            return {
+                generatedColumn: segment.generatedColumn,
+            };
+        }
+        const rewrittenPosition = positionForLineAndColumn(rewrittenLineStarts, segment.originalLine, segment.originalColumn);
+        const mappedSource = mapProgramPositionToSource(preparedFile, rewrittenPosition);
+        const mappedLineAndColumn = lineAndColumnForPosition(originalLineStarts, mappedSource.position);
+        return {
+            generatedColumn: segment.generatedColumn,
+            originalColumn: mappedLineAndColumn.column,
+            originalLine: mappedLineAndColumn.line,
+            sourceIndex: 0,
+        };
+    }));
+    const composedMap = {
+        file: emittedSourceMap.file,
+        mappings: encodeMappings(remappedSegments),
+        names: [],
+        sources: [sourcePath],
+        sourcesContent: [preparedFile.originalText],
+        version: 3,
+    };
+    return {
+        code: stripSourceMappingUrl(code),
+        map: composedMap,
+        mapText: `${JSON.stringify(composedMap)}\n`,
+    };
+}
+export function inlineSourceMapComment(mapText) {
+    const base64 = btoa(mapText);
+    return `//# sourceMappingURL=data:application/json;base64,${base64}`;
+}
+export function stripTrailingSourceMapComment(code) {
+    return stripSourceMappingUrl(code);
+}