@soundscript/soundscript 0.1.12 → 0.1.15

package/project-transform/src/main.ts

@@ -0,0 +1,28 @@
+import { runCli } from './cli.ts';
+import { parseCommand } from './config.ts';
+import { runEditorDiagnosticsWorker } from './editor_diagnostics_worker.ts';
+import { createServer } from './lsp/server.ts';
+import { createStdioTransport } from './lsp/transport.ts';
+import { runtimeArgs, runtimeCwd, runtimeExit, writeStdout } from './platform/host.ts';
+
+async function main(): Promise<void> {
+  const args = runtimeArgs();
+  const command = parseCommand(args, runtimeCwd());
+  if (command.kind === 'lsp') {
+    const transport = createStdioTransport();
+    const server = createServer(transport);
+    await server.start();
+    return;
+  }
+
+  if (command.kind === 'editor-worker') {
+    await runEditorDiagnosticsWorker();
+    return;
+  }
+
+  const result = await runCli(args);
+  writeStdout(result.output);
+  runtimeExit(result.exitCode);
+}
+
+await main();

package/project-transform/src/platform/host.js

@@ -0,0 +1,264 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _AsyncHostEventQueue_items, _AsyncHostEventQueue_waiters;
+import { spawn } from 'node:child_process';
+import { mkdirSync, readdirSync, readFileSync, rmSync, statSync, watch as watchPath, writeFileSync, } from 'node:fs';
+import { copyFile as copyFileAsync, mkdir as mkdirAsync, mkdtemp as createTempDirectoryAsync, readdir as readDirectoryAsync, readFile as readFileAsync, readlink as readLinkAsync, rm as removePathAsync, symlink as createSymlinkAsync, writeFile as writeFileAsync, } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import process from 'node:process';
+import { Readable, Writable } from 'node:stream';
+class AsyncHostEventQueue {
+    constructor() {
+        _AsyncHostEventQueue_items.set(this, []);
+        _AsyncHostEventQueue_waiters.set(this, []);
+    }
+    push(item) {
+        const waiter = __classPrivateFieldGet(this, _AsyncHostEventQueue_waiters, "f").shift();
+        if (waiter) {
+            waiter(item);
+            return;
+        }
+        __classPrivateFieldGet(this, _AsyncHostEventQueue_items, "f").push(item);
+    }
+    shift() {
+        const item = __classPrivateFieldGet(this, _AsyncHostEventQueue_items, "f").shift();
+        if (item !== undefined) {
+            return Promise.resolve(item);
+        }
+        return new Promise((resolve) => {
+            __classPrivateFieldGet(this, _AsyncHostEventQueue_waiters, "f").push(resolve);
+        });
+    }
+}
+_AsyncHostEventQueue_items = new WeakMap(), _AsyncHostEventQueue_waiters = new WeakMap();
+function collectDirectoriesRecursive(rootPath) {
+    if (!directoryExistsSync(rootPath)) {
+        return [];
+    }
+    const directories = [rootPath];
+    for (const entry of readDirectorySync(rootPath)) {
+        if (!entry.isDirectory) {
+            continue;
+        }
+        directories.push(...collectDirectoriesRecursive(join(rootPath, entry.name)));
+    }
+    return directories;
+}
+export function directoryExistsSync(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export function fileExistsSync(path) {
+    try {
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+export function pathExistsSync(path) {
+    try {
+        statSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function readBytesSync(path) {
+    return readFileSync(path);
+}
+export function readDirectorySync(path) {
+    return readdirSync(path, { withFileTypes: true }).map((entry) => ({
+        isDirectory: entry.isDirectory(),
+        isFile: entry.isFile(),
+        isSymlink: entry.isSymbolicLink(),
+        name: entry.name,
+    }));
+}
+export async function copyFile(sourcePath, destinationPath) {
+    await copyFileAsync(sourcePath, destinationPath);
+}
+export async function createSymlink(targetPath, path, type) {
+    await createSymlinkAsync(targetPath, path, type);
+}
+export async function createTempDirectory(prefix) {
+    return await createTempDirectoryAsync(join(tmpdir(), prefix));
+}
+export async function makeDirectory(path) {
+    await mkdirAsync(path, { recursive: true });
+}
+export function makeDirectorySync(path) {
+    mkdirSync(path, { recursive: true });
+}
+export function readTextFileSync(path) {
+    return readFileSync(path, 'utf8');
+}
+export async function readDirectory(path) {
+    const entries = await readDirectoryAsync(path, { withFileTypes: true });
+    return entries.map((entry) => ({
+        isDirectory: entry.isDirectory(),
+        isFile: entry.isFile(),
+        isSymlink: entry.isSymbolicLink(),
+        name: entry.name,
+    }));
+}
+export async function readLink(path) {
+    return await readLinkAsync(path);
+}
+export async function readTextFile(path) {
+    return await readFileAsync(path, 'utf8');
+}
+export async function removePath(path) {
+    await removePathAsync(path, { recursive: true, force: true });
+}
+export function removePathSync(path) {
+    rmSync(path, { recursive: true, force: true });
+}
+export async function readStdinText() {
+    process.stdin.setEncoding('utf8');
+    let text = '';
+    for await (const chunk of process.stdin) {
+        text += chunk;
+    }
+    return text;
+}
+export function runtimeExecPath() {
+    return process.execPath;
+}
+export function runtimeArgs() {
+    return process.argv.slice(2);
+}
+export function runtimeCwd() {
+    return process.cwd();
+}
+export function runtimeEnv(name) {
+    return process.env[name];
+}
+export function runtimeEnvObject() {
+    return Object.fromEntries(Object.entries(process.env).filter((entry) => {
+        return typeof entry[1] === 'string';
+    }));
+}
+export function runtimeExit(code) {
+    process.exit(code);
+}
+export function runtimeStdinReadable() {
+    return Readable.toWeb(process.stdin);
+}
+export function runtimeStdoutWritable() {
+    return Writable.toWeb(process.stdout);
+}
+export async function* watchFileSystem(rootPath) {
+    const events = new AsyncHostEventQueue();
+    const watchers = new Map();
+    let closed = false;
+    let pendingPath;
+    let debounceTimer;
+    const scheduleModifyEvent = (path) => {
+        pendingPath = path;
+        if (debounceTimer) {
+            return;
+        }
+        debounceTimer = setTimeout(() => {
+            debounceTimer = undefined;
+            events.push({
+                kind: 'modify',
+                path: pendingPath,
+            });
+            pendingPath = undefined;
+            syncWatchers();
+        }, 50);
+    };
+    const syncWatchers = () => {
+        if (closed) {
+            return;
+        }
+        const expectedPaths = new Set(collectDirectoriesRecursive(rootPath));
+        for (const [watchedPath, watcher] of watchers) {
+            if (expectedPaths.has(watchedPath)) {
+                continue;
+            }
+            watcher.close();
+            watchers.delete(watchedPath);
+        }
+        for (const watchedPath of expectedPaths) {
+            if (watchers.has(watchedPath)) {
+                continue;
+            }
+            const watcher = watchPath(watchedPath, (eventType, fileName) => {
+                const candidatePath = typeof fileName === 'string' && fileName.length > 0
+                    ? join(watchedPath, fileName)
+                    : watchedPath;
+                if (eventType === 'rename') {
+                    syncWatchers();
+                }
+                scheduleModifyEvent(candidatePath);
+            });
+            watcher.on('error', () => {
+                events.push({
+                    kind: 'other',
+                    path: watchedPath,
+                });
+                syncWatchers();
+            });
+            watchers.set(watchedPath, watcher);
+        }
+    };
+    syncWatchers();
+    try {
+        while (true) {
+            yield await events.shift();
+        }
+    }
+    finally {
+        closed = true;
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        for (const watcher of watchers.values()) {
+            watcher.close();
+        }
+    }
+}
+export async function runCommand(command, args, cwd) {
+    return await new Promise((resolve, reject) => {
+        const child = spawn(command, [...args], {
+            cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let output = '';
+        child.stdout?.setEncoding('utf8');
+        child.stdout?.on('data', (chunk) => {
+            output += chunk;
+        });
+        child.stderr?.setEncoding('utf8');
+        child.stderr?.on('data', (chunk) => {
+            output += chunk;
+        });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            resolve({
+                exitCode: code ?? 1,
+                output,
+            });
+        });
+    });
+}
+export function writeStdout(text) {
+    process.stdout.write(text);
+}
+export async function writeTextFile(path, text) {
+    await writeFileAsync(path, text, 'utf8');
+}
+export function writeTextFileSync(path, text) {
+    writeFileSync(path, text, 'utf8');
+}

package/project-transform/src/platform/host.ts

@@ -0,0 +1,343 @@
+import { spawn } from 'node:child_process';
+import {
+  type FSWatcher,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  watch as watchPath,
+  writeFileSync,
+} from 'node:fs';
+import {
+  copyFile as copyFileAsync,
+  mkdir as mkdirAsync,
+  mkdtemp as createTempDirectoryAsync,
+  readdir as readDirectoryAsync,
+  readFile as readFileAsync,
+  readlink as readLinkAsync,
+  rm as removePathAsync,
+  symlink as createSymlinkAsync,
+  writeFile as writeFileAsync,
+} from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import process from 'node:process';
+import { Readable, Writable } from 'node:stream';
+
+export interface HostDirectoryEntry {
+  isDirectory: boolean;
+  isFile: boolean;
+  isSymlink: boolean;
+  name: string;
+}
+
+export interface HostFileSystemWatchEvent {
+  kind: 'create' | 'modify' | 'other' | 'remove';
+  path?: string;
+}
+
+class AsyncHostEventQueue<T> {
+  readonly #items: T[] = [];
+  readonly #waiters: ((item: T) => void)[] = [];
+
+  push(item: T): void {
+    const waiter = this.#waiters.shift();
+    if (waiter) {
+      waiter(item);
+      return;
+    }
+
+    this.#items.push(item);
+  }
+
+  shift(): Promise<T> {
+    const item = this.#items.shift();
+    if (item !== undefined) {
+      return Promise.resolve(item);
+    }
+
+    return new Promise((resolve) => {
+      this.#waiters.push(resolve);
+    });
+  }
+}
+
+function collectDirectoriesRecursive(rootPath: string): readonly string[] {
+  if (!directoryExistsSync(rootPath)) {
+    return [];
+  }
+
+  const directories = [rootPath];
+  for (const entry of readDirectorySync(rootPath)) {
+    if (!entry.isDirectory) {
+      continue;
+    }
+
+    directories.push(...collectDirectoriesRecursive(join(rootPath, entry.name)));
+  }
+
+  return directories;
+}
+
+export function directoryExistsSync(path: string): boolean {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+export function fileExistsSync(path: string): boolean {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+
+export function pathExistsSync(path: string): boolean {
+  try {
+    statSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function readBytesSync(path: string): Uint8Array {
+  return readFileSync(path);
+}
+
+export function readDirectorySync(path: string): readonly HostDirectoryEntry[] {
+  return readdirSync(path, { withFileTypes: true }).map((entry) => ({
+    isDirectory: entry.isDirectory(),
+    isFile: entry.isFile(),
+    isSymlink: entry.isSymbolicLink(),
+    name: entry.name,
+  }));
+}
+
+export async function copyFile(sourcePath: string, destinationPath: string): Promise<void> {
+  await copyFileAsync(sourcePath, destinationPath);
+}
+
+export async function createSymlink(
+  targetPath: string,
+  path: string,
+  type?: 'dir' | 'file' | 'junction',
+): Promise<void> {
+  await createSymlinkAsync(targetPath, path, type);
+}
+
+export async function createTempDirectory(prefix: string): Promise<string> {
+  return await createTempDirectoryAsync(join(tmpdir(), prefix));
+}
+
+export async function makeDirectory(path: string): Promise<void> {
+  await mkdirAsync(path, { recursive: true });
+}
+
+export function makeDirectorySync(path: string): void {
+  mkdirSync(path, { recursive: true });
+}
+
+export function readTextFileSync(path: string): string {
+  return readFileSync(path, 'utf8');
+}
+
+export async function readDirectory(path: string): Promise<readonly HostDirectoryEntry[]> {
+  const entries = await readDirectoryAsync(path, { withFileTypes: true });
+  return entries.map((entry) => ({
+    isDirectory: entry.isDirectory(),
+    isFile: entry.isFile(),
+    isSymlink: entry.isSymbolicLink(),
+    name: entry.name,
+  }));
+}
+
+export async function readLink(path: string): Promise<string> {
+  return await readLinkAsync(path);
+}
+
+export async function readTextFile(path: string): Promise<string> {
+  return await readFileAsync(path, 'utf8');
+}
+
+export async function removePath(path: string): Promise<void> {
+  await removePathAsync(path, { recursive: true, force: true });
+}
+
+export function removePathSync(path: string): void {
+  rmSync(path, { recursive: true, force: true });
+}
+
+export async function readStdinText(): Promise<string> {
+  process.stdin.setEncoding('utf8');
+  let text = '';
+  for await (const chunk of process.stdin) {
+    text += chunk;
+  }
+  return text;
+}
+
+export function runtimeExecPath(): string {
+  return process.execPath;
+}
+
+export function runtimeArgs(): readonly string[] {
+  return process.argv.slice(2);
+}
+
+export function runtimeCwd(): string {
+  return process.cwd();
+}
+
+export function runtimeEnv(name: string): string | undefined {
+  return process.env[name];
+}
+
+export function runtimeEnvObject(): Record<string, string> {
+  return Object.fromEntries(
+    Object.entries(process.env).filter((entry): entry is [string, string] => {
+      return typeof entry[1] === 'string';
+    }),
+  );
+}
+
+export function runtimeExit(code: number): never {
+  process.exit(code);
+}
+
+export function runtimeStdinReadable(): ReadableStream<Uint8Array> {
+  return Readable.toWeb(process.stdin) as ReadableStream<Uint8Array>;
+}
+
+export function runtimeStdoutWritable(): WritableStream<Uint8Array> {
+  return Writable.toWeb(process.stdout) as WritableStream<Uint8Array>;
+}
+
+export async function* watchFileSystem(
+  rootPath: string,
+): AsyncIterable<HostFileSystemWatchEvent> {
+  const events = new AsyncHostEventQueue<HostFileSystemWatchEvent>();
+  const watchers = new Map<string, FSWatcher>();
+  let closed = false;
+  let pendingPath: string | undefined;
+  let debounceTimer: ReturnType<typeof setTimeout> | undefined;
+
+  const scheduleModifyEvent = (path: string): void => {
+    pendingPath = path;
+    if (debounceTimer) {
+      return;
+    }
+
+    debounceTimer = setTimeout(() => {
+      debounceTimer = undefined;
+      events.push({
+        kind: 'modify',
+        path: pendingPath,
+      });
+      pendingPath = undefined;
+      syncWatchers();
+    }, 50);
+  };
+
+  const syncWatchers = (): void => {
+    if (closed) {
+      return;
+    }
+
+    const expectedPaths = new Set(collectDirectoriesRecursive(rootPath));
+    for (const [watchedPath, watcher] of watchers) {
+      if (expectedPaths.has(watchedPath)) {
+        continue;
+      }
+
+      watcher.close();
+      watchers.delete(watchedPath);
+    }
+
+    for (const watchedPath of expectedPaths) {
+      if (watchers.has(watchedPath)) {
+        continue;
+      }
+
+      const watcher = watchPath(watchedPath, (eventType, fileName) => {
+        const candidatePath = typeof fileName === 'string' && fileName.length > 0
+          ? join(watchedPath, fileName)
+          : watchedPath;
+        if (eventType === 'rename') {
+          syncWatchers();
+        }
+        scheduleModifyEvent(candidatePath);
+      });
+      watcher.on('error', () => {
+        events.push({
+          kind: 'other',
+          path: watchedPath,
+        });
+        syncWatchers();
+      });
+      watchers.set(watchedPath, watcher);
+    }
+  };
+
+  syncWatchers();
+
+  try {
+    while (true) {
+      yield await events.shift();
+    }
+  } finally {
+    closed = true;
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    for (const watcher of watchers.values()) {
+      watcher.close();
+    }
+  }
+}
+
+export async function runCommand(
+  command: string,
+  args: readonly string[],
+  cwd: string,
+): Promise<{ exitCode: number; output: string }> {
+  return await new Promise((resolve, reject) => {
+    const child = spawn(command, [...args], {
+      cwd,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let output = '';
+
+    child.stdout?.setEncoding('utf8');
+    child.stdout?.on('data', (chunk: string) => {
+      output += chunk;
+    });
+    child.stderr?.setEncoding('utf8');
+    child.stderr?.on('data', (chunk: string) => {
+      output += chunk;
+    });
+    child.on('error', reject);
+    child.on('close', (code) => {
+      resolve({
+        exitCode: code ?? 1,
+        output,
+      });
+    });
+  });
+}
+
+export function writeStdout(text: string): void {
+  process.stdout.write(text);
+}
+
+export async function writeTextFile(path: string, text: string): Promise<void> {
+  await writeFileAsync(path, text, 'utf8');
+}
+
+export function writeTextFileSync(path: string, text: string): void {
+  writeFileSync(path, text, 'utf8');
+}

package/project-transform/src/platform/path.js

@@ -0,0 +1,8 @@
+import { fileURLToPath, pathToFileURL } from 'node:url';
+export { basename, dirname, extname, isAbsolute, join, normalize, relative, resolve, } from 'node:path';
+export function fromFileUrl(url) {
+    return fileURLToPath(url);
+}
+export function toFileUrl(path) {
+    return pathToFileURL(path);
+}

package/project-transform/src/platform/path.ts

@@ -0,0 +1,20 @@
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+export {
+  basename,
+  dirname,
+  extname,
+  isAbsolute,
+  join,
+  normalize,
+  relative,
+  resolve,
+} from 'node:path';
+
+export function fromFileUrl(url: string | URL): string {
+  return fileURLToPath(url);
+}
+
+export function toFileUrl(path: string): URL {
+  return pathToFileURL(path);
+}