@scelar/nodepod 1.0.0

package/src/polyfills/repl.ts

@@ -0,0 +1,134 @@
+// lightweight REPL stub for compatibility
+
+
+import { EventEmitter } from "./events";
+
+/* ------------------------------------------------------------------ */
+/*  Constants                                                          */
+/* ------------------------------------------------------------------ */
+
+export const REPL_MODE_SLOPPY = Symbol.for("repl-sloppy");
+export const REPL_MODE_STRICT = Symbol.for("repl-strict");
+
+/* ------------------------------------------------------------------ */
+/*  Recoverable                                                        */
+/* ------------------------------------------------------------------ */
+
+export interface Recoverable extends SyntaxError {
+  err: Error;
+}
+
+interface RecoverableConstructor {
+  new (err: Error): Recoverable;
+  (this: any, err: Error): void;
+  prototype: any;
+}
+
+export const Recoverable = function Recoverable(this: any, err: Error) {
+  if (!this) return;
+  SyntaxError.call(this, err.message);
+  this.message = err.message;
+  this.name = "SyntaxError";
+  this.err = err;
+  if (Error.captureStackTrace) Error.captureStackTrace(this, Recoverable);
+} as unknown as RecoverableConstructor;
+
+Object.setPrototypeOf(Recoverable.prototype, SyntaxError.prototype);
+
+/* ------------------------------------------------------------------ */
+/*  REPLServer                                                         */
+/* ------------------------------------------------------------------ */
+
+export interface REPLServer extends EventEmitter {
+  context: Record<string, unknown>;
+  terminal: boolean;
+  _prompt: string;
+  _commands: Map<string, { help: string; action: Function }>;
+  setPrompt(prompt: string): void;
+  getPrompt(): string;
+  displayPrompt(_preserveCursor?: boolean): void;
+  defineCommand(keyword: string, cmd: { help?: string; action: Function } | Function): void;
+  close(): void;
+  setupHistory(_historyPath: string, cb: (err: Error | null, repl: REPLServer) => void): void;
+}
+
+interface REPLServerConstructor {
+  new (options?: string | Record<string, unknown>): REPLServer;
+  (this: any, options?: string | Record<string, unknown>): void;
+  prototype: any;
+}
+
+export const REPLServer = function REPLServer(this: any, options?: string | Record<string, unknown>) {
+  if (!this) return;
+  EventEmitter.call(this);
+  this.context = Object.create(null);
+  this.terminal = false;
+  this._prompt = "> ";
+  this._commands = new Map<string, { help: string; action: Function }>();
+  if (typeof options === "string") {
+    this._prompt = options;
+  } else if (options) {
+    if (typeof options.prompt === "string") this._prompt = options.prompt;
+    if (options.terminal !== undefined) this.terminal = !!options.terminal;
+  }
+} as unknown as REPLServerConstructor;
+
+Object.setPrototypeOf(REPLServer.prototype, EventEmitter.prototype);
+
+REPLServer.prototype.setPrompt = function setPrompt(this: any, prompt: string): void {
+  this._prompt = prompt;
+};
+
+REPLServer.prototype.getPrompt = function getPrompt(this: any): string {
+  return this._prompt;
+};
+
+REPLServer.prototype.displayPrompt = function displayPrompt(_preserveCursor?: boolean): void {
+};
+
+REPLServer.prototype.defineCommand = function defineCommand(
+  this: any,
+  keyword: string,
+  cmd: { help?: string; action: Function } | Function,
+): void {
+  if (typeof cmd === "function") {
+    this._commands.set(keyword, { help: "", action: cmd });
+  } else {
+    this._commands.set(keyword, { help: cmd.help || "", action: cmd.action });
+  }
+};
+
+REPLServer.prototype.close = function close(this: any): void {
+  this.emit("exit");
+  this.emit("close");
+};
+
+REPLServer.prototype.setupHistory = function setupHistory(
+  this: any,
+  _historyPath: string,
+  cb: (err: Error | null, repl: REPLServer) => void,
+): void {
+  cb(null, this);
+};
+
+/* ------------------------------------------------------------------ */
+/*  Factory                                                            */
+/* ------------------------------------------------------------------ */
+
+export function start(
+  options?: string | Record<string, unknown>,
+): REPLServer {
+  return new REPLServer(options);
+}
+
+/* ------------------------------------------------------------------ */
+/*  Default export                                                     */
+/* ------------------------------------------------------------------ */
+
+export default {
+  start,
+  REPLServer,
+  Recoverable,
+  REPL_MODE_SLOPPY,
+  REPL_MODE_STRICT,
+};

package/src/polyfills/rollup.ts

@@ -0,0 +1,119 @@
+// Rollup polyfill that lazy-loads @rollup/browser from CDN
+
+import * as acorn from "acorn";
+import acornJsx from "acorn-jsx";
+import {
+  CDN_ROLLUP_BROWSER,
+  PINNED_ROLLUP_BROWSER,
+  cdnImport,
+} from "../constants/cdn-urls";
+
+// acorn parser extended with JSX support
+const acornJsxParser = (acorn.Parser as any).extend(acornJsx());
+
+let cachedRollup: unknown = null;
+let loadingPromise: Promise<unknown> | null = null;
+
+async function ensureRollup(): Promise<unknown> {
+  if (cachedRollup) return cachedRollup;
+  if (loadingPromise) return loadingPromise;
+
+  loadingPromise = (async () => {
+    try {
+      const mod = await cdnImport(CDN_ROLLUP_BROWSER);
+      cachedRollup = mod;
+      return mod;
+    } catch (err) {
+      loadingPromise = null;
+      throw new Error(
+        `rollup: failed to load @rollup/browser from CDN -- ${err}`,
+      );
+    }
+  })();
+
+  return loadingPromise;
+}
+
+export const VERSION: string = PINNED_ROLLUP_BROWSER;
+
+// .write() is a no-op in browser
+export async function rollup(inputOptions: unknown): Promise<unknown> {
+  const r = (await ensureRollup()) as {
+    rollup: (o: unknown) => Promise<unknown>;
+  };
+  return r.rollup(inputOptions);
+}
+
+export async function watch(watchOptions: unknown): Promise<unknown> {
+  const r = (await ensureRollup()) as { watch: (o: unknown) => unknown };
+  return r.watch(watchOptions);
+}
+
+export function defineConfig<T>(config: T): T {
+  return config;
+}
+
+// falls back to acorn-jsx if plain acorn fails (e.g. JSX in source)
+export function parseAst(
+  source: string,
+  opts?: { allowReturnOutsideFunction?: boolean; jsx?: boolean },
+): unknown {
+  const parseOpts = {
+    ecmaVersion: "latest" as const,
+    sourceType: "module" as const,
+    allowReturnOutsideFunction: opts?.allowReturnOutsideFunction ?? false,
+    locations: true,
+  };
+
+  if (opts?.jsx) {
+    return acornJsxParser.parse(source, parseOpts);
+  }
+
+  try {
+    return acorn.parse(source, parseOpts);
+  } catch {
+    return acornJsxParser.parse(source, parseOpts);
+  }
+}
+
+export async function parseAstAsync(
+  source: string,
+  opts?: {
+    allowReturnOutsideFunction?: boolean;
+    jsx?: boolean;
+    signal?: AbortSignal;
+  },
+): Promise<unknown> {
+  return parseAst(source, {
+    allowReturnOutsideFunction: opts?.allowReturnOutsideFunction,
+    jsx: opts?.jsx,
+  });
+}
+
+// prevents "unsupported platform" error when Rollup probes for native bindings
+export function getPackageBase(): string {
+  return "";
+}
+
+export { ensureRollup as loadRollup };
+
+export interface Plugin {
+  name: string;
+  [key: string]: unknown;
+}
+
+export interface PluginContext {
+  meta: { rollupVersion: string };
+  parse: (code: string) => unknown;
+  [key: string]: unknown;
+}
+
+export default {
+  VERSION,
+  rollup,
+  watch,
+  defineConfig,
+  parseAst,
+  parseAstAsync,
+  loadRollup: ensureRollup,
+};

package/src/polyfills/sea.ts

@@ -0,0 +1,33 @@
+// stub - not available in browser
+
+
+/* ------------------------------------------------------------------ */
+/*  API                                                                */
+/* ------------------------------------------------------------------ */
+
+export function isSea(): boolean {
+  return false;
+}
+
+export function getAsset(_key: string): never {
+  throw new Error("Single Executable Applications (SEA) are not supported in the browser");
+}
+
+export function getAssetAsBlob(_key: string): never {
+  throw new Error("Single Executable Applications (SEA) are not supported in the browser");
+}
+
+export function getRawAsset(_key: string): never {
+  throw new Error("Single Executable Applications (SEA) are not supported in the browser");
+}
+
+/* ------------------------------------------------------------------ */
+/*  Default export                                                     */
+/* ------------------------------------------------------------------ */
+
+export default {
+  isSea,
+  getAsset,
+  getAssetAsBlob,
+  getRawAsset,
+};

package/src/polyfills/sqlite.ts

@@ -0,0 +1,78 @@
+// stub - not available in browser (would need sql.js WASM)
+
+
+/* ------------------------------------------------------------------ */
+/*  StatementSync                                                      */
+/* ------------------------------------------------------------------ */
+
+export interface StatementSync {
+  run(..._params: unknown[]): object;
+  get(..._params: unknown[]): unknown;
+  all(..._params: unknown[]): unknown[];
+  expandedSQL(): string;
+  sourceSQL(): string;
+}
+
+interface StatementSyncConstructor {
+  new (): StatementSync;
+  (this: any): void;
+  prototype: any;
+}
+
+export const StatementSync = function StatementSync(this: any) {
+  if (!this) return;
+} as unknown as StatementSyncConstructor;
+
+StatementSync.prototype.run = function run(..._params: unknown[]): object {
+  throw new Error("node:sqlite is not supported in the browser environment");
+};
+StatementSync.prototype.get = function get(..._params: unknown[]): unknown {
+  throw new Error("node:sqlite is not supported in the browser environment");
+};
+StatementSync.prototype.all = function all(..._params: unknown[]): unknown[] {
+  throw new Error("node:sqlite is not supported in the browser environment");
+};
+StatementSync.prototype.expandedSQL = function expandedSQL(): string {
+  return "";
+};
+StatementSync.prototype.sourceSQL = function sourceSQL(): string {
+  return "";
+};
+
+/* ------------------------------------------------------------------ */
+/*  DatabaseSync                                                       */
+/* ------------------------------------------------------------------ */
+
+export interface DatabaseSync {
+  close(): void;
+  exec(_sql: string): void;
+  prepare(_sql: string): StatementSync;
+  open(): void;
+}
+
+interface DatabaseSyncConstructor {
+  new (_location: string, _options?: object): DatabaseSync;
+  (this: any, _location: string, _options?: object): void;
+  prototype: any;
+}
+
+export const DatabaseSync = function DatabaseSync(this: any, _location: string, _options?: object) {
+  if (!this) return;
+  throw new Error("node:sqlite is not supported in the browser environment");
+} as unknown as DatabaseSyncConstructor;
+
+DatabaseSync.prototype.close = function close(): void {};
+DatabaseSync.prototype.exec = function exec(_sql: string): void {};
+DatabaseSync.prototype.prepare = function prepare(_sql: string): StatementSync {
+  throw new Error("node:sqlite is not supported in the browser environment");
+};
+DatabaseSync.prototype.open = function open(): void {};
+
+/* ------------------------------------------------------------------ */
+/*  Default export                                                     */
+/* ------------------------------------------------------------------ */
+
+export default {
+  DatabaseSync,
+  StatementSync,
+};