@dbx-tools/projen 0.9.51 → 0.9.58

package/shims/python-node/fs-promises.ts

@@ -1,179 +0,0 @@
-import { Buffer } from "node:buffer";
-
-import { pythonHost } from "./host.ts";
-
-function nodeError(error: unknown, code: string, path: string): Error {
-  return Object.assign(error instanceof Error ? error : new Error(String(error)), { code, path });
-}
-
-function translatePythonError(cause: unknown, path: string): never {
-  const message = String(cause);
-  if (/FileNotFoundError|Errno 2/.test(message)) throw nodeError(cause, "ENOENT", path);
-  if (/FileExistsError|Errno 17/.test(message)) throw nodeError(cause, "EEXIST", path);
-  if (/PermissionError|Errno 13/.test(message)) throw nodeError(cause, "EACCES", path);
-  throw cause;
-}
-
-export async function access(path: string): Promise<void> {
-  try {
-    await pythonHost().file.stat(String(path));
-  } catch (cause) {
-    translatePythonError(cause, path);
-  }
-}
-
-export async function chmod(path: string, mode: number): Promise<void> {
-  await pythonHost().file.chmod(String(path), mode);
-}
-
-export async function appendFile(
-  path: string,
-  content: string | ArrayBuffer | ArrayBufferView,
-): Promise<void> {
-  const bytes =
-    typeof content === "string"
-      ? new TextEncoder().encode(content)
-      : content instanceof ArrayBuffer
-        ? new Uint8Array(content)
-        : new Uint8Array(content.buffer, content.byteOffset, content.byteLength);
-  await pythonHost().file.appendBytes(String(path), Array.from(bytes));
-}
-
-export async function copyFile(source: string, destination: string): Promise<void> {
-  await pythonHost().file.copy(String(source), String(destination));
-}
-
-export async function mkdir(
-  path: string,
-  options: { recursive?: boolean } = {},
-): Promise<string | undefined> {
-  let created: boolean;
-  try {
-    created = await pythonHost().file.mkdir(String(path), options.recursive === true);
-  } catch (cause) {
-    if (/FileExistsError|Errno 17/.test(String(cause))) {
-      if (options.recursive) return undefined;
-      throw nodeError(cause, "EEXIST", path);
-    }
-    throw cause;
-  }
-  if (!created && !options.recursive) throw nodeError(new Error(`EEXIST: ${path}`), "EEXIST", path);
-  return created ? String(path) : undefined;
-}
-
-export async function mkdtemp(prefix: string): Promise<string> {
-  return pythonHost().file.mkdtemp(String(prefix));
-}
-
-export async function readdir(
-  path: string,
-  options: { withFileTypes?: boolean } = {},
-): Promise<unknown[]> {
-  const entries = await pythonHost().file.readDirectory(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 async function readFile(
-  path: string,
-  options?: string | { encoding?: string | null },
-): Promise<string | Uint8Array> {
-  try {
-    const bytes = Uint8Array.from(await pythonHost().file.readBytes(String(path)));
-    const encoding = typeof options === "string" ? options : options?.encoding;
-    return encoding ? new TextDecoder(encoding).decode(bytes) : Buffer.from(bytes);
-  } catch (cause) {
-    translatePythonError(cause, path);
-  }
-}
-
-export async function realpath(path: string): Promise<string> {
-  try {
-    return await pythonHost().file.realpath(String(path));
-  } catch (cause) {
-    translatePythonError(cause, path);
-  }
-}
-
-export async function rename(source: string, destination: string): Promise<void> {
-  await pythonHost().file.rename(String(source), String(destination));
-}
-
-export async function rm(
-  path: string,
-  options: { recursive?: boolean; force?: boolean } = {},
-): Promise<void> {
-  await pythonHost().file.remove(String(path), options.recursive === true, options.force === true);
-}
-
-export async function unlink(path: string): Promise<void> {
-  // No synchronous existence precheck: let the async remove run and treat a
-  // missing file as success, so this never blocks on a sync Python call.
-  try {
-    await pythonHost().file.remove(String(path), false, true);
-  } catch (cause) {
-    if (/FileNotFoundError|Errno 2|ENOENT/.test(String(cause))) return;
-    translatePythonError(cause, path);
-  }
-}
-
-export async function stat(path: string): Promise<unknown> {
-  let value: Awaited<ReturnType<ReturnType<typeof pythonHost>["file"]["stat"]>>;
-  try {
-    value = await pythonHost().file.stat(String(path));
-  } catch (cause) {
-    translatePythonError(cause, 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 async function writeFile(
-  path: string,
-  content: string | ArrayBuffer | ArrayBufferView,
-  options: { mode?: number } = {},
-): Promise<void> {
-  const bytes =
-    typeof content === "string"
-      ? new TextEncoder().encode(content)
-      : content instanceof ArrayBuffer
-        ? new Uint8Array(content)
-        : new Uint8Array(content.buffer, content.byteOffset, content.byteLength);
-  await pythonHost().file.writeBytes(String(path), Array.from(bytes), options.mode);
-}
-
-export async function open(): Promise<never> {
-  throw Object.assign(new Error("File descriptors are unavailable in PythonMonkey"), {
-    code: "ENOSYS",
-  });
-}
-
-export default {
-  access,
-  appendFile,
-  chmod,
-  copyFile,
-  mkdir,
-  mkdtemp,
-  open,
-  readFile,
-  readdir,
-  realpath,
-  rename,
-  rm,
-  stat,
-  unlink,
-  writeFile,
-};

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();
-}