@soundscript/soundscript 0.1.13 → 0.1.15

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

@@ -0,0 +1,297 @@
+import type { PreparedSourceFile } from '../frontend/project_frontend.ts';
+import { mapProgramPositionToSource } from '../frontend/project_frontend.ts';
+
+interface SourceMapV3 {
+  version: 3;
+  file?: string;
+  sourceRoot?: string;
+  sources: string[];
+  sourcesContent?: (string | null)[];
+  names: string[];
+  mappings: string;
+}
+
+interface DecodedSegment {
+  generatedColumn: number;
+  nameIndex?: number;
+  originalColumn?: number;
+  originalLine?: number;
+  sourceIndex?: number;
+}
+
+const BASE64_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const BASE64_LOOKUP = new Map([...BASE64_ALPHABET].map((character, index) => [character, index]));
+
+function toVlqSigned(value: number): number {
+  return value < 0 ? ((-value) << 1) + 1 : value << 1;
+}
+
+function fromVlqSigned(value: number): number {
+  const isNegative = (value & 1) === 1;
+  const shifted = value >> 1;
+  return isNegative ? -shifted : shifted;
+}
+
+function encodeVlqValue(value: number): string {
+  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: string, startIndex: number): { nextIndex: number; value: number } {
+  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: string): DecodedSegment[][] {
+  if (mappings.length === 0) {
+    return [[]];
+  }
+
+  const lines = mappings.split(';');
+  const decoded: DecodedSegment[][] = [];
+
+  let previousSourceIndex = 0;
+  let previousOriginalLine = 0;
+  let previousOriginalColumn = 0;
+  let previousNameIndex = 0;
+
+  for (const line of lines) {
+    const segments: DecodedSegment[] = [];
+    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: DecodedSegment = {
+          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: readonly DecodedSegment[][]): string {
+  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: string): number[] {
+  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: readonly number[],
+  line: number,
+  column: number,
+): number {
+  const lineStart = lineStarts[line] ?? lineStarts[lineStarts.length - 1] ?? 0;
+  return lineStart + column;
+}
+
+function lineAndColumnForPosition(
+  lineStarts: readonly number[],
+  position: number,
+): { column: number; line: number } {
+  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: string): string {
+  return code.replace(/\n\/\/# sourceMappingURL=.*$/u, '');
+}
+
+export interface ComposedSourceMapResult {
+  code: string;
+  map: SourceMapV3;
+  mapText: string;
+}
+
+export function composeTranspiledSourceMapToOriginal(
+  code: string,
+  emittedSourceMapText: string,
+  preparedFile: PreparedSourceFile,
+  sourcePath: string,
+): ComposedSourceMapResult {
+  const emittedSourceMap = JSON.parse(emittedSourceMapText) as SourceMapV3;
+  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: SourceMapV3 = {
+    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: string): string {
+  const base64 = btoa(mapText);
+  return `//# sourceMappingURL=data:application/json;base64,${base64}`;
+}
+
+export function stripTrailingSourceMapComment(code: string): string {
+  return stripSourceMappingUrl(code);
+}

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

@@ -0,0 +1,148 @@
+import ts from 'typescript';
+import { buildRewriteStageFromTexts } from '../frontend/error_normalization.js';
+import { normalizeValueSemanticsInProgramForFile, normalizeValueSemanticsInSourceText, } from '../frontend/value_normalization.js';
+import { builtinRuntimeImportSpecifier } from '../soundscript_runtime_specifiers.js';
+import { composeTranspiledSourceMapToOriginal, stripTrailingSourceMapComment, } from './source_maps.js';
+function rewriteRuntimeModuleSpecifier(specifier, moduleSpecifierMode) {
+    const builtinRuntimeSpecifier = builtinRuntimeImportSpecifier(specifier);
+    if (builtinRuntimeSpecifier) {
+        return builtinRuntimeSpecifier;
+    }
+    if (moduleSpecifierMode === 'preserve') {
+        return specifier;
+    }
+    if (!specifier.startsWith('.') && !specifier.startsWith('/')) {
+        return specifier;
+    }
+    if (specifier.endsWith('.js') || specifier.endsWith('.mjs') || specifier.endsWith('.cjs')) {
+        return specifier;
+    }
+    if (specifier.endsWith('.json') || specifier.endsWith('.css') || specifier.endsWith('.wasm')) {
+        return specifier;
+    }
+    if (moduleSpecifierMode === 'source-sts') {
+        if (specifier.endsWith('.sts')) {
+            return specifier;
+        }
+        if (specifier.endsWith('.ts') || specifier.endsWith('.tsx') || specifier.endsWith('.mts') ||
+            specifier.endsWith('.cts') || specifier.endsWith('.jsx')) {
+            return `${specifier.slice(0, specifier.lastIndexOf('.'))}.sts`;
+        }
+        return specifier;
+    }
+    if (specifier.endsWith('.sts') || specifier.endsWith('.ts') || specifier.endsWith('.tsx') ||
+        specifier.endsWith('.mts') || specifier.endsWith('.cts') || specifier.endsWith('.jsx')) {
+        return `${specifier.slice(0, specifier.lastIndexOf('.'))}.js`;
+    }
+    return `${specifier}.js`;
+}
+function rewriteRuntimeModuleSpecifiers(code, fileName, moduleSpecifierMode) {
+    const scriptKind = /\.(?:[cm]?tsx|jsx)$/iu.test(fileName)
+        ? ts.ScriptKind.TSX
+        : /\.(?:[cm]?js)$/iu.test(fileName)
+            ? ts.ScriptKind.JS
+            : ts.ScriptKind.TS;
+    const sourceFile = ts.createSourceFile(fileName, code, ts.ScriptTarget.ES2022, true, scriptKind);
+    const replacements = [];
+    function addReplacement(literal) {
+        const nextText = rewriteRuntimeModuleSpecifier(literal.text, moduleSpecifierMode);
+        if (nextText === literal.text) {
+            return;
+        }
+        replacements.push({
+            start: literal.getStart(sourceFile) + 1,
+            end: literal.getEnd() - 1,
+            text: nextText,
+        });
+    }
+    function visit(node) {
+        if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) &&
+            node.moduleSpecifier &&
+            ts.isStringLiteralLike(node.moduleSpecifier)) {
+            addReplacement(node.moduleSpecifier);
+        }
+        else if (ts.isCallExpression(node) &&
+            node.expression.kind === ts.SyntaxKind.ImportKeyword &&
+            node.arguments.length >= 1) {
+            const firstArgument = node.arguments[0];
+            if (ts.isStringLiteralLike(firstArgument)) {
+                addReplacement(firstArgument);
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    if (replacements.length === 0) {
+        return code;
+    }
+    const sorted = replacements.sort((left, right) => right.start - left.start);
+    let rewritten = code;
+    for (const replacement of sorted) {
+        rewritten = `${rewritten.slice(0, replacement.start)}${replacement.text}${rewritten.slice(replacement.end)}`;
+    }
+    return rewritten;
+}
+export function rewriteModuleSpecifiersForEmit(sourceText, fileName, options = {}) {
+    return rewriteRuntimeModuleSpecifiers(sourceText, fileName, options.moduleSpecifierMode ?? 'emit-js');
+}
+function normalizeTranspileParseFileName(fileName) {
+    return fileName.endsWith('.sts') ? `${fileName.slice(0, -4)}.tsx` : fileName;
+}
+function transpileModule(sourceText, fileName, options) {
+    return ts.transpileModule(sourceText, {
+        compilerOptions: {
+            jsx: ts.JsxEmit.ReactJSX,
+            module: options.module ?? ts.ModuleKind.ES2022,
+            sourceMap: true,
+            target: options.target ?? ts.ScriptTarget.ES2022,
+        },
+        fileName: normalizeTranspileParseFileName(fileName),
+        reportDiagnostics: false,
+    });
+}
+function normalizeTranspiledMap(transpiled, sourcePath, sourceText, moduleSpecifierMode) {
+    const map = JSON.parse(transpiled.sourceMapText ?? '{}');
+    map.version = 3;
+    map.names = map.names ?? [];
+    map.sources = [sourcePath];
+    map.sourcesContent = [sourceText];
+    const rewrittenCode = rewriteRuntimeModuleSpecifiers(transpiled.outputText, sourcePath, moduleSpecifierMode);
+    return {
+        code: stripTrailingSourceMapComment(rewrittenCode),
+        mapText: `${JSON.stringify(map)}\n`,
+    };
+}
+function normalizePreparedValueSemantics(sourceFileName, preparedFile, valueProgram) {
+    const normalized = valueProgram
+        ? normalizeValueSemanticsInProgramForFile(valueProgram, sourceFileName) ??
+            normalizeValueSemanticsInSourceText(sourceFileName, preparedFile.rewrittenText)
+        : normalizeValueSemanticsInSourceText(sourceFileName, preparedFile.rewrittenText);
+    if (!normalized || normalized.rewriteStage.rewrittenText === preparedFile.rewrittenText) {
+        return preparedFile;
+    }
+    return {
+        ...preparedFile,
+        postRewriteStage: buildRewriteStageFromTexts(sourceFileName, preparedFile.rewriteResult.rewrittenText, normalized.rewriteStage.rewrittenText),
+        rewrittenText: normalized.rewriteStage.rewrittenText,
+    };
+}
+export function transpilePreparedSoundscriptModuleToEsm(sourceFileName, outputFileName, preparedFile, options = {}) {
+    const runtimePreparedFile = normalizePreparedValueSemantics(sourceFileName, preparedFile, options.valueProgram);
+    const transpiled = transpileModule(runtimePreparedFile.rewrittenText, sourceFileName, {
+        ...options,
+        sourceMapFileName: outputFileName,
+    });
+    const rewrittenCode = rewriteRuntimeModuleSpecifiers(transpiled.outputText, sourceFileName, options.moduleSpecifierMode ?? 'emit-js');
+    const composed = composeTranspiledSourceMapToOriginal(rewrittenCode, transpiled.sourceMapText ?? '{"version":3,"sources":[],"names":[],"mappings":""}', runtimePreparedFile, sourceFileName);
+    return {
+        code: composed.code,
+        mapText: composed.mapText,
+    };
+}
+export function transpileTypeScriptModuleToEsm(sourceFileName, outputFileName, sourceText, options = {}) {
+    const transpiled = transpileModule(sourceText, sourceFileName, {
+        ...options,
+        sourceMapFileName: outputFileName,
+    });
+    return normalizeTranspiledMap(transpiled, sourceFileName, sourceText, options.moduleSpecifierMode ?? 'emit-js');
+}