@run0/jiki 0.1.0

package/src/polyfills/readdirp.ts

@@ -0,0 +1,72 @@
+import type { MemFS } from "../memfs";
+import * as pathShim from "./path";
+
+let _vfs: MemFS | null = null;
+export function initReaddirp(vfs: MemFS): void {
+  _vfs = vfs;
+}
+
+export interface ReaddirpEntry {
+  path: string;
+  fullPath: string;
+  basename: string;
+  dirent: { isFile(): boolean; isDirectory(): boolean };
+}
+
+export default function readdirp(
+  root: string,
+  options?: {
+    fileFilter?: string | string[];
+    directoryFilter?: string | string[];
+    depth?: number;
+  },
+): AsyncIterable<ReaddirpEntry> & {
+  [Symbol.asyncIterator](): AsyncIterableIterator<ReaddirpEntry>;
+} {
+  const entries: ReaddirpEntry[] = [];
+
+  if (_vfs) {
+    const collect = (dir: string, depth: number) => {
+      if (options?.depth !== undefined && depth > options.depth) return;
+      try {
+        const items = _vfs!.readdirSync(dir);
+        for (const name of items) {
+          const fullPath = pathShim.join(dir, name);
+          try {
+            const stat = _vfs!.statSync(fullPath);
+            entries.push({
+              path: pathShim.relative(root, fullPath),
+              fullPath,
+              basename: name,
+              dirent: {
+                isFile: () => stat.isFile(),
+                isDirectory: () => stat.isDirectory(),
+              },
+            });
+            if (stat.isDirectory()) collect(fullPath, depth + 1);
+          } catch {}
+        }
+      } catch {}
+    };
+    collect(root, 0);
+  }
+
+  let idx = 0;
+  return {
+    [Symbol.asyncIterator](): AsyncIterableIterator<ReaddirpEntry> {
+      return {
+        next(): Promise<IteratorResult<ReaddirpEntry>> {
+          if (idx < entries.length)
+            return Promise.resolve({ value: entries[idx++], done: false });
+          return Promise.resolve({
+            value: undefined as unknown as ReaddirpEntry,
+            done: true,
+          });
+        },
+        [Symbol.asyncIterator]() {
+          return this;
+        },
+      };
+    },
+  };
+}

package/src/polyfills/readline.ts

@@ -0,0 +1,80 @@
+import { EventEmitter } from "./events";
+
+export class Interface extends EventEmitter {
+  private _input: unknown;
+  private _output: unknown;
+  terminal: boolean;
+
+  constructor(options?: {
+    input?: unknown;
+    output?: unknown;
+    terminal?: boolean;
+  }) {
+    super();
+    this._input = options?.input;
+    this._output = options?.output;
+    this.terminal = options?.terminal ?? false;
+  }
+
+  question(query: string, cb: (answer: string) => void): void {
+    if (this._output && typeof (this._output as any).write === "function") {
+      (this._output as any).write(query);
+    }
+    cb("");
+  }
+
+  close(): void {
+    this.emit("close");
+  }
+  pause(): this {
+    return this;
+  }
+  resume(): this {
+    return this;
+  }
+  prompt(_preserveCursor?: boolean): void {}
+  setPrompt(_prompt: string): void {}
+  write(_data: string): void {}
+}
+
+export function createInterface(options?: unknown): Interface {
+  return new Interface(
+    options as { input?: unknown; output?: unknown; terminal?: boolean },
+  );
+}
+
+export function clearLine(
+  _stream: unknown,
+  _dir: number,
+  _cb?: () => void,
+): boolean {
+  return true;
+}
+export function clearScreenDown(_stream: unknown, _cb?: () => void): boolean {
+  return true;
+}
+export function cursorTo(
+  _stream: unknown,
+  _x: number,
+  _y?: number,
+  _cb?: () => void,
+): boolean {
+  return true;
+}
+export function moveCursor(
+  _stream: unknown,
+  _dx: number,
+  _dy: number,
+  _cb?: () => void,
+): boolean {
+  return true;
+}
+
+export default {
+  Interface,
+  createInterface,
+  clearLine,
+  clearScreenDown,
+  cursorTo,
+  moveCursor,
+};