@dbx-tools/projen 0.9.51 → 0.9.54

package/shims/python-node/fs.ts

@@ -1,173 +0,0 @@
-import { Readable, Writable } from "node:stream";
-
-import * as promises from "./fs-promises.ts";
-import { pythonHost } from "./host.ts";
-
-type Callback<T = undefined> = (error: Error | null, value?: T) => void;
-
-function callback<T>(operation: Promise<T>, done: Callback<T>): void {
-  void operation.then(
-    (value) => done(null, value),
-    (error) => done(error as Error),
-  );
-}
-
-export function existsSync(path: string): boolean {
-  return pythonHost().file.exists(String(path));
-}
-
-export function readFileSync(path: string, _encoding?: string): string {
-  return pythonHost().file.readTextSync(String(path));
-}
-
-export function readdirSync(path: string, options: { withFileTypes?: boolean } = {}): unknown[] {
-  const entries = pythonHost().file.readDirectorySync(String(path));
-  if (!options.withFileTypes) return entries.map((entry) => entry.name);
-  return entries.map((entry) => ({
-    name: entry.name,
-    isDirectory: () => entry.directory,
-    isFile: () => entry.file,
-    isSymbolicLink: () => false,
-  }));
-}
-
-export function readlinkSync(path: string): string {
-  return pythonHost().file.readLinkSync(String(path));
-}
-
-export function realpathSync(path: string): string {
-  return pythonHost().file.realpathSync(String(path));
-}
-
-realpathSync.native = realpathSync;
-
-export function lstatSync(path: string): unknown {
-  const value = pythonHost().file.statSync(String(path));
-  return {
-    mode: value.mode,
-    mtime: new Date(value.mtimeMs),
-    mtimeMs: value.mtimeMs,
-    size: value.size,
-    isDirectory: () => value.directory,
-    isFile: () => value.file,
-    isSymbolicLink: () => false,
-  };
-}
-
-export function createReadStream(path: string): Readable {
-  const stream = new Readable({ read() {} });
-  void pythonHost()
-    .file.readBytes(String(path))
-    .then(
-      (content) => {
-        stream.push(Uint8Array.from(content));
-        stream.push(null);
-      },
-      (error) => stream.destroy(error as Error),
-    );
-  return stream;
-}
-
-export function createWriteStream(path: string, options: { mode?: number } = {}): Writable {
-  const chunks: number[] = [];
-  return new Writable({
-    write(chunk, _encoding, done) {
-      chunks.push(...new Uint8Array(chunk));
-      done();
-    },
-    final(done) {
-      void pythonHost()
-        .file.writeBytes(String(path), chunks, options.mode)
-        .then(
-          () => done(),
-          (error) => done(error as Error),
-        );
-    },
-  });
-}
-
-export function mkdir(path: string, options: object | Callback, done?: Callback): void {
-  const settings = typeof options === "function" ? {} : (options as { recursive?: boolean });
-  const callbackValue = typeof options === "function" ? options : done;
-  callback(
-    promises.mkdir(path, settings).then(() => undefined),
-    callbackValue ?? (() => {}),
-  );
-}
-
-export function realpath(path: string, done: Callback<string>): void {
-  callback(promises.realpath(path), done);
-}
-
-export function stat(path: string, done: Callback<unknown>): void {
-  callback(promises.stat(path), done);
-}
-
-export const lstat = stat;
-
-export function rmdir(path: string, done: Callback): void {
-  callback(
-    promises.rm(path).then(() => undefined),
-    done,
-  );
-}
-
-export function utimes(path: string, atime: Date, mtime: Date, done: Callback): void {
-  callback(
-    pythonHost()
-      .file.touch(String(path), atime.getTime(), mtime.getTime())
-      .then(() => undefined),
-    done,
-  );
-}
-
-export function open(_path: string, _flags: unknown, done: Callback<number>): void {
-  done(
-    Object.assign(new Error("File descriptors are unavailable in PythonMonkey"), {
-      code: "ENOSYS",
-    }),
-  );
-}
-
-export function close(_fd: number, done: Callback): void {
-  done(null);
-}
-
-export function openSync(): never {
-  throw Object.assign(new Error("File descriptors are unavailable in PythonMonkey"), {
-    code: "ENOSYS",
-  });
-}
-
-export function closeSync(): void {}
-
-export const constants = {
-  O_RDONLY: 0,
-  O_WRONLY: 1,
-  O_SYMLINK: 0,
-};
-
-export { promises };
-
-export default {
-  close,
-  closeSync,
-  constants,
-  createReadStream,
-  createWriteStream,
-  existsSync,
-  lstat,
-  mkdir,
-  open,
-  openSync,
-  promises,
-  readFileSync,
-  readdirSync,
-  realpath,
-  realpathSync,
-  readlinkSync,
-  rmdir,
-  stat,
-  lstatSync,
-  utimes,
-};

package/shims/python-node/headers.ts

@@ -1,75 +0,0 @@
-export class PythonHeaders implements Iterable<[string, string]> {
-  readonly #values = new Map<string, string[]>();
-
-  constructor(init?: HeadersInit) {
-    if (!init) return;
-    if (Symbol.iterator in Object(init)) {
-      for (const [name, value] of init as Iterable<[string, string]>) this.append(name, value);
-      return;
-    }
-    for (const [name, value] of Object.entries(init)) this.set(name, String(value));
-  }
-
-  append(name: string, value: string): void {
-    const key = normalizeName(name);
-    const values = this.#values.get(key) ?? [];
-    values.push(String(value));
-    this.#values.set(key, values);
-  }
-
-  delete(name: string): void {
-    this.#values.delete(normalizeName(name));
-  }
-
-  entries(): IterableIterator<[string, string]> {
-    return this.#iterateEntries();
-  }
-
-  forEach(
-    callback: (value: string, key: string, parent: PythonHeaders) => void,
-    thisArg?: unknown,
-  ): void {
-    for (const [key, value] of this) callback.call(thisArg, value, key, this);
-  }
-
-  get(name: string): string | null {
-    const values = this.#values.get(normalizeName(name));
-    return values ? values.join(", ") : null;
-  }
-
-  getSetCookie(): string[] {
-    return [...(this.#values.get("set-cookie") ?? [])];
-  }
-
-  has(name: string): boolean {
-    return this.#values.has(normalizeName(name));
-  }
-
-  keys(): IterableIterator<string> {
-    return this.#values.keys();
-  }
-
-  set(name: string, value: string): void {
-    this.#values.set(normalizeName(name), [String(value)]);
-  }
-
-  values(): IterableIterator<string> {
-    return this.#iterateValues();
-  }
-
-  [Symbol.iterator](): IterableIterator<[string, string]> {
-    return this.entries();
-  }
-
-  *#iterateEntries(): IterableIterator<[string, string]> {
-    for (const [name, values] of this.#values) yield [name, values.join(", ")];
-  }
-
-  *#iterateValues(): IterableIterator<string> {
-    for (const [, value] of this) yield value;
-  }
-}
-
-function normalizeName(name: string): string {
-  return String(name).toLowerCase();
-}

package/shims/python-node/host.ts

@@ -1,341 +0,0 @@
-interface PythonBridge {
-  eval(source: string): unknown;
-}
-
-interface PythonCompletedProcess {
-  returncode: number;
-  stdout: string | null;
-  stderr: string | null;
-}
-
-interface PythonHttpResponse {
-  status_code: number;
-  headers: Record<string, string>;
-  content: Iterable<number>;
-}
-
-export interface PythonFileHost {
-  appendBytes(path: string, content: number[]): Promise<void>;
-  chmod(path: string, mode: number): Promise<void>;
-  copy(source: string, destination: string): Promise<void>;
-  exists(path: string): boolean;
-  mkdir(path: string, recursive: boolean): Promise<boolean>;
-  mkdtemp(prefix: string): Promise<string>;
-  readBytes(path: string): Promise<number[]>;
-  readDirectory(path: string): Promise<{ name: string; directory: boolean; file: boolean }[]>;
-  readTextSync(path: string): string;
-  readDirectorySync(path: string): { name: string; directory: boolean; file: boolean }[];
-  readLinkSync(path: string): string;
-  realpath(path: string): Promise<string>;
-  realpathSync(path: string): string;
-  remove(path: string, recursive: boolean, force: boolean): Promise<void>;
-  rename(source: string, destination: string): Promise<void>;
-  stat(path: string): Promise<{
-    directory: boolean;
-    file: boolean;
-    mode: number;
-    mtimeMs: number;
-    size: number;
-  }>;
-  statSync(path: string): {
-    directory: boolean;
-    file: boolean;
-    mode: number;
-    mtimeMs: number;
-    size: number;
-  };
-  touch(path: string, atimeMs: number, mtimeMs: number): Promise<void>;
-  writeBytes(path: string, content: number[], mode?: number): Promise<void>;
-}
-
-export interface PythonPathHost {
-  basename(path: string): string;
-  dirname(path: string): string;
-  fileUrlToPath(url: string): string;
-  isAbsolute(path: string): boolean;
-  join(parts: string[]): string;
-  relative(from: string, to: string): string;
-  resolve(parts: string[]): string;
-}
-
-export interface PythonProcessResult {
-  exitCode: number;
-  stdout?: string;
-  stderr?: string;
-}
-
-/** A started subprocess: await {@link wait} for its result, or {@link kill} it. */
-export interface PythonProcessHandle {
-  /** Terminate the child (SIGKILL). No-op once it has already exited. */
-  kill(): void;
-  /** Resolve with the child's result once it exits (runs off the main thread). */
-  wait(): Promise<PythonProcessResult>;
-}
-
-export interface PythonRuntimeHost {
-  crypto: {
-    digest(algorithm: string, content: number[], encoding?: "hex" | "base64"): string | number[];
-    hashes(): string[];
-    randomBytes(length: number): number[];
-  };
-  file: PythonFileHost;
-  os: {
-    homedir(): string;
-    tmpdir(): string;
-  };
-  path: PythonPathHost;
-  http: {
-    fetch(
-      url: string,
-      method?: string,
-      headers?: Record<string, string>,
-      body?: string,
-      timeoutMs?: number,
-    ): Promise<{ status: number; headers: Record<string, string>; body: number[] }>;
-  };
-  process: {
-    start(
-      command: string,
-      args: string[],
-      environment: Record<string, string> | undefined,
-      input: string | undefined,
-    ): PythonProcessHandle;
-  };
-}
-
-type PythonFunction = (...args: any[]) => any;
-
-const python = (globalThis as typeof globalThis & { python?: PythonBridge }).python;
-if (!python) throw new Error("PythonMonkey globalThis.python is unavailable");
-
-function evaluate<T extends PythonFunction>(source: string): T {
-  return python!.eval(source) as T;
-}
-
-const toThread = evaluate<PythonFunction>("__import__('asyncio').to_thread");
-const osPath = {
-  basename: evaluate<PythonFunction>("__import__('os').path.basename"),
-  dirname: evaluate<PythonFunction>("__import__('os').path.dirname"),
-  exists: evaluate<PythonFunction>("__import__('os').path.exists"),
-  isAbsolute: evaluate<PythonFunction>("__import__('os').path.isabs"),
-  join: evaluate<PythonFunction>("lambda parts: __import__('os').path.join(*list(parts))"),
-  realpath: evaluate<PythonFunction>("__import__('os').path.realpath"),
-  relative: evaluate<PythonFunction>("__import__('os').path.relpath"),
-  resolve: evaluate<PythonFunction>(
-    "lambda parts: __import__('os').path.abspath(__import__('os').path.join(*list(parts))) if list(parts) else __import__('os').getcwd()",
-  ),
-};
-const readBytes = evaluate<PythonFunction>("lambda path: list(open(path, 'rb').read())");
-const readText = evaluate<PythonFunction>("lambda path: open(path, encoding='utf-8').read()");
-const writeBytes = evaluate<PythonFunction>(
-  "lambda path, content: open(path, 'wb').write(bytes(int(value) for value in content))",
-);
-const appendBytes = evaluate<PythonFunction>(
-  "lambda path, content: open(path, 'ab').write(bytes(int(value) for value in content))",
-);
-const mkdir = evaluate<PythonFunction>(
-  "lambda path, recursive: __import__('os').makedirs(path, exist_ok=recursive) if recursive else __import__('os').mkdir(path)",
-);
-const listDirectory = evaluate<PythonFunction>(
-  "lambda path: [{'name': entry.name, 'directory': entry.is_dir(), 'file': entry.is_file()} for entry in __import__('pathlib').Path(path).iterdir()]",
-);
-const readLink = evaluate<PythonFunction>("__import__('os').readlink");
-const statPath = evaluate<PythonFunction>(
-  "lambda path: {'directory': __import__('os').path.isdir(path), 'file': __import__('os').path.isfile(path), 'mode': __import__('os').stat(path).st_mode, 'mtimeMs': __import__('os').stat(path).st_mtime * 1000, 'size': __import__('os').stat(path).st_size}",
-);
-const popen = evaluate<PythonFunction>(
-  "lambda command, args, environment, input_text: __import__('subprocess').Popen([command, *list(args)], env=dict(environment) if environment is not None else None, stdin=(__import__('subprocess').PIPE if input_text is not None else None), stdout=__import__('subprocess').PIPE, stderr=__import__('subprocess').PIPE, text=True)",
-);
-const communicate = evaluate<PythonFunction>(
-  "lambda proc, input_text: (lambda out: {'returncode': proc.returncode, 'stdout': out[0], 'stderr': out[1]})(proc.communicate(input=input_text))",
-);
-const killProcess = evaluate<PythonFunction>("lambda proc: proc.kill()");
-const requestHttp = evaluate<PythonFunction>(
-  "lambda url, method, headers, body, timeout: __import__('httpx').request(method or 'GET', url, headers=dict(headers) if headers is not None else None, content=body, timeout=(timeout / 1000) if timeout is not None else 30, follow_redirects=True)",
-);
-const chmod = evaluate<PythonFunction>(
-  "lambda path, mode: __import__('os').chmod(path, int(mode))",
-);
-const isDir = evaluate<PythonFunction>("__import__('os').path.isdir");
-const rmtree = evaluate<PythonFunction>("__import__('shutil').rmtree");
-const rmdir = evaluate<PythonFunction>("__import__('os').rmdir");
-const unlink = evaluate<PythonFunction>("__import__('os').unlink");
-
-const host: PythonRuntimeHost = {
-  crypto: {
-    digest: evaluate<PythonFunction>(
-      "lambda algorithm, content, encoding: (lambda value: value.hexdigest() if encoding == 'hex' else __import__('base64').b64encode(value.digest()).decode('ascii') if encoding == 'base64' else list(value.digest()))(__import__('hashlib').new(algorithm, bytes(int(item) for item in content)))",
-    ),
-    hashes: evaluate<PythonFunction>("lambda: sorted(__import__('hashlib').algorithms_available)"),
-    randomBytes: evaluate<PythonFunction>(
-      "lambda length: list(__import__('os').urandom(int(length)))",
-    ),
-  },
-  file: {
-    async appendBytes(path, content) {
-      await toThread(appendBytes, path, content);
-    },
-    async chmod(path, mode) {
-      await toThread(chmod, path, mode);
-    },
-    async copy(source, destination) {
-      await toThread(
-        evaluate<PythonFunction>("__import__('shutil').copyfile"),
-        source,
-        destination,
-      );
-    },
-    exists: (path) => Boolean(osPath.exists(path)),
-    async mkdir(path, recursive) {
-      if (await toThread(osPath.exists, path)) return false;
-      await toThread(mkdir, path, recursive);
-      return true;
-    },
-    async mkdtemp(prefix) {
-      return toThread(
-        evaluate<PythonFunction>("__import__('tempfile').mkdtemp"),
-        undefined,
-        prefix,
-      );
-    },
-    async readBytes(path) {
-      return toThread(readBytes, path);
-    },
-    async readDirectory(path) {
-      return toThread(listDirectory, path);
-    },
-    readDirectorySync: (path) => listDirectory(path),
-    readLinkSync: (path) => String(readLink(path)),
-    readTextSync: (path) => String(readText(path)),
-    async realpath(path) {
-      return String(await toThread(osPath.realpath, path));
-    },
-    realpathSync: (path) => String(osPath.realpath(path)),
-    async remove(path, recursive, force) {
-      if (!(await toThread(osPath.exists, path))) {
-        if (!force) throw Object.assign(new Error(`ENOENT: ${path}`), { code: "ENOENT" });
-        return;
-      }
-      const isDirectory = await toThread(isDir, path);
-      const operation = isDirectory ? (recursive ? rmtree : rmdir) : unlink;
-      await toThread(operation, path);
-    },
-    async rename(source, destination) {
-      await toThread(evaluate<PythonFunction>("__import__('os').replace"), source, destination);
-    },
-    async stat(path) {
-      return toThread(statPath, path);
-    },
-    statSync: (path) => statPath(path),
-    async touch(path, atimeMs, mtimeMs) {
-      await toThread(
-        evaluate<PythonFunction>(
-          "lambda path, atime, mtime: __import__('os').utime(path, (atime / 1000, mtime / 1000))",
-        ),
-        path,
-        atimeMs,
-        mtimeMs,
-      );
-    },
-    async writeBytes(path, content, mode) {
-      await toThread(writeBytes, path, content);
-      if (mode !== undefined) await toThread(chmod, path, mode);
-    },
-  },
-  http: {
-    async fetch(url, method, headers, body, timeoutMs) {
-      const response = (await toThread(
-        requestHttp,
-        url,
-        method,
-        headers,
-        body,
-        timeoutMs,
-      )) as PythonHttpResponse;
-      return {
-        status: response.status_code,
-        headers: Object.fromEntries(Object.entries(response.headers)),
-        body: Array.from(response.content),
-      };
-    },
-  },
-  os: {
-    homedir: evaluate<PythonFunction>("lambda: __import__('pathlib').Path.home().as_posix()"),
-    tmpdir: evaluate<PythonFunction>("__import__('tempfile').gettempdir"),
-  },
-  path: {
-    basename: (path) => String(osPath.basename(path)),
-    dirname: (path) => String(osPath.dirname(path)),
-    fileUrlToPath: evaluate<PythonFunction>(
-      "lambda url: __import__('urllib.parse', fromlist=['urlparse']).unquote(__import__('urllib.parse', fromlist=['urlparse']).urlparse(url).path)",
-    ),
-    isAbsolute: (path) => Boolean(osPath.isAbsolute(path)),
-    join: (parts) => String(osPath.join(parts)),
-    relative: (from, to) => String(osPath.relative(to, from)),
-    resolve: (parts) => String(osPath.resolve(parts)),
-  },
-  process: {
-    start(command, args, environment, input) {
-      // Popen (not subprocess.run) so the child is killable: an aborted caller
-      // can terminate it instead of leaking a background process. There is no
-      // imposed timeout - the child runs to completion (an interactive login may
-      // legitimately take minutes); the caller owns cancellation.
-      const proc = popen(command, args, environment, input);
-      let killed = false;
-      return {
-        kill() {
-          if (killed) return;
-          killed = true;
-          try {
-            killProcess(proc);
-          } catch {
-            // The child already exited; there is nothing to signal.
-          }
-        },
-        async wait() {
-          // communicate() blocks until exit, so run it off the main thread.
-          const result = (await toThread(communicate, proc, input)) as PythonCompletedProcess;
-          return {
-            exitCode: result.returncode,
-            ...(result.stdout?.trim() ? { stdout: result.stdout.trim() } : {}),
-            ...(result.stderr?.trim() ? { stderr: result.stderr.trim() } : {}),
-          };
-        },
-      };
-    },
-  },
-};
-
-export function installPythonGlobals(): void {
-  const globals = globalThis as typeof globalThis & {
-    global?: typeof globalThis;
-    self?: typeof globalThis;
-    window?: typeof globalThis;
-    process?: Record<string, unknown>;
-  };
-  globals.global = globalThis;
-  globals.self = globalThis;
-  globals.window = globalThis;
-  globals.process ??= {
-    arch: String(evaluate<PythonFunction>("__import__('platform').machine")())
-      .replace("aarch64", "arm64")
-      .replace("x86_64", "x64"),
-    argv: [],
-    browser: true,
-    cwd: evaluate<PythonFunction>("__import__('os').getcwd"),
-    env: evaluate<PythonFunction>("lambda: dict(__import__('os').environ)")(),
-    nextTick: (callback: (...args: unknown[]) => void, ...args: unknown[]) =>
-      Promise.resolve().then(() => callback(...args)),
-    platform: { Darwin: "darwin", Linux: "linux", Windows: "win32" }[
-      String(evaluate<PythonFunction>("__import__('platform').system")())
-    ],
-    version: "v22.0.0",
-    versions: {},
-  };
-}
-
-installPythonGlobals();
-
-export function pythonHost(): PythonRuntimeHost {
-  return host;
-}

package/shims/python-node/os.ts

@@ -1,20 +0,0 @@
-import { pythonHost } from "./host.ts";
-
-export const constants = {
-  errno: {
-    EEXIST: 17,
-    ENOTDIR: 20,
-    EISDIR: 21,
-    EINVAL: 22,
-  },
-} as const;
-
-export function homedir(): string {
-  return pythonHost().os.homedir();
-}
-
-export function tmpdir(): string {
-  return pythonHost().os.tmpdir();
-}
-
-export default { constants, homedir, tmpdir };

package/shims/python-node/process.ts

@@ -1,13 +0,0 @@
-import { installPythonGlobals } from "./host.ts";
-
-installPythonGlobals();
-
-export default process;
-export const arch = process.arch;
-export const argv = process.argv;
-export const cwd = process.cwd;
-export const env = process.env;
-export const nextTick = process.nextTick;
-export const platform = process.platform;
-export const version = process.version;
-export const versions = process.versions;

package/shims/python-node/readline.ts

@@ -1,37 +0,0 @@
-/**
- * Async line reader used by subprocess output capture in PythonMonkey bundles.
- *
- * @module
- */
-
-interface ReadLineOptions {
-  readonly input: AsyncIterable<unknown>;
-}
-
-class PythonReadLine implements AsyncIterable<string> {
-  private closed = false;
-
-  constructor(private readonly input: AsyncIterable<unknown>) {}
-
-  async *[Symbol.asyncIterator](): AsyncIterator<string> {
-    let buffered = "";
-    for await (const chunk of this.input) {
-      if (this.closed) break;
-      buffered += String(chunk);
-      const lines = buffered.split(/\r?\n/);
-      buffered = lines.pop() ?? "";
-      for (const line of lines) yield line;
-    }
-    if (!this.closed && buffered) yield buffered.replace(/\r$/, "");
-  }
-
-  close(): void {
-    this.closed = true;
-  }
-}
-
-export function createInterface(options: ReadLineOptions): PythonReadLine {
-  return new PythonReadLine(options.input);
-}
-
-export default { createInterface };

package/shims/python-node/tsconfig.json

@@ -1,24 +0,0 @@
-// ~~ Generated by projen. To modify, edit .projenrc.js and run "bunx projen".
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "lib": [
-      "ES2022",
-      "DOM"
-    ],
-    "types": [
-      "node"
-    ],
-    "noEmit": true,
-    "skipLibCheck": true,
-    "strict": false
-  },
-  "include": [
-    "*.ts"
-  ],
-  "exclude": [
-    "node_modules"
-  ]
-}