@scelar/nodepod 1.0.0

package/src/polyfills/http2.ts

@@ -0,0 +1,199 @@
+// stub - not available in browser
+
+
+import { EventEmitter } from "./events";
+
+/* ------------------------------------------------------------------ */
+/*  Sessions                                                           */
+/* ------------------------------------------------------------------ */
+
+export interface Http2Session extends EventEmitter {
+  close(done?: () => void): void;
+  destroy(_err?: Error, _code?: number): void;
+  readonly destroyed: boolean;
+  readonly encrypted: boolean;
+  readonly closed: boolean;
+  ping(_cb: (err: Error | null, dur: number, buf: Uint8Array) => void): boolean;
+  ref(): void;
+  unref(): void;
+  setTimeout(_ms: number, _cb?: () => void): void;
+}
+
+export const Http2Session = function Http2Session(this: any) {
+  if (!this) return;
+  EventEmitter.call(this);
+} as unknown as { new(): Http2Session; prototype: any };
+
+Object.setPrototypeOf(Http2Session.prototype, EventEmitter.prototype);
+
+Http2Session.prototype.close = function close(done?: () => void): void {
+  if (done) setTimeout(done, 0);
+};
+Http2Session.prototype.destroy = function destroy(_err?: Error, _code?: number): void {};
+Object.defineProperty(Http2Session.prototype, 'destroyed', { get() { return false; }, configurable: true });
+Object.defineProperty(Http2Session.prototype, 'encrypted', { get() { return false; }, configurable: true });
+Object.defineProperty(Http2Session.prototype, 'closed', { get() { return false; }, configurable: true });
+Http2Session.prototype.ping = function ping(
+  _cb: (err: Error | null, dur: number, buf: Uint8Array) => void,
+): boolean { return false; };
+Http2Session.prototype.ref = function ref(): void {};
+Http2Session.prototype.unref = function unref(): void {};
+Http2Session.prototype.setTimeout = function setTimeout(_ms: number, _cb?: () => void): void {};
+
+export interface ClientHttp2Session extends Http2Session {}
+
+export const ClientHttp2Session = function ClientHttp2Session(this: any) {
+  if (!this) return;
+  (Http2Session as any).call(this);
+} as unknown as { new(): ClientHttp2Session; prototype: any };
+
+Object.setPrototypeOf(ClientHttp2Session.prototype, Http2Session.prototype);
+
+export interface ServerHttp2Session extends Http2Session {}
+
+export const ServerHttp2Session = function ServerHttp2Session(this: any) {
+  if (!this) return;
+  (Http2Session as any).call(this);
+} as unknown as { new(): ServerHttp2Session; prototype: any };
+
+Object.setPrototypeOf(ServerHttp2Session.prototype, Http2Session.prototype);
+
+/* ------------------------------------------------------------------ */
+/*  Streams                                                            */
+/* ------------------------------------------------------------------ */
+
+export interface Http2Stream extends EventEmitter {
+  close(_code?: number, _cb?: () => void): void;
+  readonly id: number;
+  readonly pending: boolean;
+  readonly destroyed: boolean;
+  readonly closed: boolean;
+  priority(_opts: unknown): void;
+  setTimeout(_ms: number, _cb?: () => void): void;
+  end(_data?: unknown, _enc?: string, _cb?: () => void): void;
+}
+
+export const Http2Stream = function Http2Stream(this: any) {
+  if (!this) return;
+  EventEmitter.call(this);
+} as unknown as { new(): Http2Stream; prototype: any };
+
+Object.setPrototypeOf(Http2Stream.prototype, EventEmitter.prototype);
+
+Http2Stream.prototype.close = function close(_code?: number, _cb?: () => void): void {};
+Object.defineProperty(Http2Stream.prototype, 'id', { get() { return 0; }, configurable: true });
+Object.defineProperty(Http2Stream.prototype, 'pending', { get() { return false; }, configurable: true });
+Object.defineProperty(Http2Stream.prototype, 'destroyed', { get() { return false; }, configurable: true });
+Object.defineProperty(Http2Stream.prototype, 'closed', { get() { return false; }, configurable: true });
+Http2Stream.prototype.priority = function priority(_opts: unknown): void {};
+Http2Stream.prototype.setTimeout = function setTimeout(_ms: number, _cb?: () => void): void {};
+Http2Stream.prototype.end = function end(_data?: unknown, _enc?: string, _cb?: () => void): void {};
+
+/* ------------------------------------------------------------------ */
+/*  Request / Response                                                 */
+/* ------------------------------------------------------------------ */
+
+export interface Http2ServerRequest extends EventEmitter {}
+
+export const Http2ServerRequest = function Http2ServerRequest(this: any) {
+  if (!this) return;
+  EventEmitter.call(this);
+} as unknown as { new(): Http2ServerRequest; prototype: any };
+
+Object.setPrototypeOf(Http2ServerRequest.prototype, EventEmitter.prototype);
+
+export interface Http2ServerResponse extends EventEmitter {
+  writeHead(_code: number, _hdrs?: object): this;
+  end(_data?: unknown): void;
+}
+
+export const Http2ServerResponse = function Http2ServerResponse(this: any) {
+  if (!this) return;
+  EventEmitter.call(this);
+} as unknown as { new(): Http2ServerResponse; prototype: any };
+
+Object.setPrototypeOf(Http2ServerResponse.prototype, EventEmitter.prototype);
+
+Http2ServerResponse.prototype.writeHead = function writeHead(_code: number, _hdrs?: object) { return this; };
+Http2ServerResponse.prototype.end = function end(_data?: unknown): void {};
+
+/* ------------------------------------------------------------------ */
+/*  Factories                                                          */
+/* ------------------------------------------------------------------ */
+
+export function createServer(
+  _opts?: unknown,
+  _handler?: unknown,
+): EventEmitter {
+  return new EventEmitter();
+}
+
+export function createSecureServer(
+  _opts?: unknown,
+  _handler?: unknown,
+): EventEmitter {
+  return new EventEmitter();
+}
+
+export function connect(
+  _authority: string,
+  _opts?: unknown,
+  _cb?: () => void,
+): ClientHttp2Session {
+  return new ClientHttp2Session();
+}
+
+/* ------------------------------------------------------------------ */
+/*  Constants                                                          */
+/* ------------------------------------------------------------------ */
+
+export const constants = {
+  NGHTTP2_SESSION_SERVER: 0,
+  NGHTTP2_SESSION_CLIENT: 1,
+  HTTP2_HEADER_STATUS: ":status",
+  HTTP2_HEADER_METHOD: ":method",
+  HTTP2_HEADER_AUTHORITY: ":authority",
+  HTTP2_HEADER_SCHEME: ":scheme",
+  HTTP2_HEADER_PATH: ":path",
+  HTTP_STATUS_OK: 200,
+  HTTP_STATUS_NOT_FOUND: 404,
+};
+
+/* ------------------------------------------------------------------ */
+/*  Settings helpers                                                   */
+/* ------------------------------------------------------------------ */
+
+export function getDefaultSettings(): object {
+  return {};
+}
+
+export function getPackedSettings(_settings?: object): Uint8Array {
+  return new Uint8Array(0);
+}
+
+export function getUnpackedSettings(_buf: Uint8Array): object {
+  return {};
+}
+
+export const sensitiveHeaders = Symbol("sensitiveHeaders");
+
+/* ------------------------------------------------------------------ */
+/*  Default export                                                     */
+/* ------------------------------------------------------------------ */
+
+export default {
+  Http2Session,
+  ClientHttp2Session,
+  ServerHttp2Session,
+  Http2Stream,
+  Http2ServerRequest,
+  Http2ServerResponse,
+  createServer,
+  createSecureServer,
+  connect,
+  constants,
+  getDefaultSettings,
+  getPackedSettings,
+  getUnpackedSettings,
+  sensitiveHeaders,
+};

package/src/polyfills/https.ts

@@ -0,0 +1,76 @@
+// Thin facade over http that forces https protocol on client requests
+
+
+import {
+  Server,
+  IncomingMessage,
+  ServerResponse,
+  ClientRequest,
+  createServer,
+  STATUS_CODES,
+  METHODS,
+  getServer,
+  getAllServers,
+  setServerListenCallback,
+  setServerCloseCallback,
+  _buildClientRequest,
+  Agent,
+  globalAgent,
+} from './http';
+
+import type { ConnectionOptions, AgentConfig } from './http';
+
+// Re-export all shared types and classes under HTTPS naming
+export {
+  Server,
+  IncomingMessage,
+  ServerResponse,
+  ClientRequest,
+  createServer,
+  STATUS_CODES,
+  METHODS,
+  getServer,
+  getAllServers,
+  setServerListenCallback,
+  setServerCloseCallback,
+  Agent,
+  globalAgent,
+};
+
+export type { ConnectionOptions, AgentConfig };
+
+export function request(
+  target: string | URL | ConnectionOptions,
+  optsOrCb?: ConnectionOptions | ((res: IncomingMessage) => void),
+  cb?: (res: IncomingMessage) => void
+): ClientRequest {
+  return _buildClientRequest(target, optsOrCb, cb, 'https');
+}
+
+export function get(
+  target: string | URL | ConnectionOptions,
+  optsOrCb?: ConnectionOptions | ((res: IncomingMessage) => void),
+  cb?: (res: IncomingMessage) => void
+): ClientRequest {
+  const cr = _buildClientRequest(target, optsOrCb, cb, 'https');
+  cr.end();
+  return cr;
+}
+
+export default {
+  Server,
+  IncomingMessage,
+  ServerResponse,
+  ClientRequest,
+  createServer,
+  request,
+  get,
+  STATUS_CODES,
+  METHODS,
+  getServer,
+  getAllServers,
+  setServerListenCallback,
+  setServerCloseCallback,
+  Agent,
+  globalAgent,
+};

package/src/polyfills/inspector.ts

@@ -0,0 +1,62 @@
+// stub - not available in browser
+
+
+import { EventEmitter } from "./events";
+
+/* ------------------------------------------------------------------ */
+/*  Session                                                            */
+/* ------------------------------------------------------------------ */
+
+export interface Session extends EventEmitter {
+  connect(): void;
+  connectToMainThread(): void;
+  disconnect(): void;
+  post(
+    _method: string,
+    _params?: object,
+    _cb?: (err: Error | null, result?: object) => void,
+  ): void;
+}
+
+export const Session = function Session(this: any) {
+  if (!this) return;
+  EventEmitter.call(this);
+} as unknown as { new(): Session; prototype: any };
+
+Object.setPrototypeOf(Session.prototype, EventEmitter.prototype);
+
+Session.prototype.connect = function connect(): void {};
+Session.prototype.connectToMainThread = function connectToMainThread(): void {};
+Session.prototype.disconnect = function disconnect(): void {};
+Session.prototype.post = function post(
+  _method: string,
+  _params?: object,
+  _cb?: (err: Error | null, result?: object) => void,
+): void {
+  if (_cb) setTimeout(() => _cb(null, {}), 0);
+};
+
+/* ------------------------------------------------------------------ */
+/*  Module-level helpers                                               */
+/* ------------------------------------------------------------------ */
+
+export function open(_port?: number, _host?: string, _wait?: boolean): void {}
+export function close(): void {}
+export function url(): string | undefined {
+  return undefined;
+}
+export function waitForDebugger(): void {}
+export { nativeConsole as console };
+
+/* ------------------------------------------------------------------ */
+/*  Default export                                                     */
+/* ------------------------------------------------------------------ */
+
+export default {
+  Session,
+  open,
+  close,
+  url,
+  waitForDebugger,
+  console: nativeConsole,
+};

package/src/polyfills/lightningcss.ts

@@ -0,0 +1,105 @@
+// Lazy-loads lightningcss-wasm from CDN since native .node binaries can't run in browser.
+// Feature flags are inlined for synchronous access; actual transform/bundle delegates to WASM.
+
+import { CDN_LIGHTNINGCSS_WASM, cdnImport } from "../constants/cdn-urls";
+
+// Bitfield constants -- must be available synchronously before WASM loads
+
+export const Features = {
+  Nesting:                        1,
+  NotSelectorList:                2,
+  DirSelector:                    4,
+  LangSelectorList:               8,
+  IsSelector:                    16,
+  TextDecorationThicknessPercent: 32,
+  MediaIntervalSyntax:           64,
+  MediaRangeSyntax:             128,
+  CustomMediaQueries:           256,
+  ClampFunction:                512,
+  ColorFunction:               1024,
+  OklabColors:                 2048,
+  LabColors:                   4096,
+  P3Colors:                    8192,
+  HexAlphaColors:             16384,
+  SpaceSeparatedColorNotation: 32768,
+  FontFamilySystemUi:         65536,
+  DoublePositionGradients:   131072,
+  VendorPrefixes:            262144,
+  LogicalProperties:         524288,
+  LightDark:                1048576,
+  // Composite flags
+  Selectors:                     31,
+  MediaQueries:                 448,
+  Colors:                   1113088,
+} as const;
+
+let wasmMod: any = null;
+let initPromise: Promise<void> | null = null;
+
+async function ensureInit(): Promise<void> {
+  if (wasmMod) return;
+  if (initPromise) return initPromise;
+
+  initPromise = (async () => {
+    try {
+      const mod = await cdnImport(CDN_LIGHTNINGCSS_WASM);
+      if (typeof mod.default === "function") {
+        await mod.default();
+      } else if (typeof mod.init === "function") {
+        await mod.init();
+      }
+      wasmMod = mod;
+    } catch (err) {
+      initPromise = null;
+      throw new Error(`lightningcss: WASM initialization failed -- ${err}`);
+    }
+  })();
+
+  return initPromise;
+}
+
+// start eagerly so WASM is ready by the time transform() is called
+ensureInit();
+
+export function transform(opts: any): any {
+  if (!wasmMod) throw new Error("lightningcss: WASM not ready yet — call await init() first");
+  return wasmMod.transform(opts);
+}
+
+export function transformStyleAttribute(opts: any): any {
+  if (!wasmMod) throw new Error("lightningcss: WASM not ready yet");
+  return wasmMod.transformStyleAttribute(opts);
+}
+
+export function bundle(opts: any): any {
+  if (!wasmMod) throw new Error("lightningcss: WASM not ready yet");
+  return wasmMod.bundle(opts);
+}
+
+export async function bundleAsync(opts: any): Promise<any> {
+  await ensureInit();
+  return wasmMod.bundleAsync(opts);
+}
+
+export function composeVisitors(visitors: any[]): any {
+  if (!wasmMod) throw new Error("lightningcss: WASM not ready yet");
+  return wasmMod.composeVisitors(visitors);
+}
+
+export function browserslistToTargets(browserslist: any): any {
+  if (wasmMod?.browserslistToTargets) return wasmMod.browserslistToTargets(browserslist);
+  return {};
+}
+
+export { ensureInit as init };
+
+export default {
+  transform,
+  transformStyleAttribute,
+  bundle,
+  bundleAsync,
+  composeVisitors,
+  Features,
+  browserslistToTargets,
+  init: ensureInit,
+};

package/src/polyfills/module.ts

@@ -0,0 +1,191 @@
+// Module polyfill (builtinModules, createRequire, Module class)
+
+export const builtinModules: string[] = [
+  "assert",
+  "assert/strict",
+  "async_hooks",
+  "buffer",
+  "child_process",
+  "cluster",
+  "console",
+  "constants",
+  "crypto",
+  "dgram",
+  "diagnostics_channel",
+  "dns",
+  "dns/promises",
+  "domain",
+  "events",
+  "fs",
+  "fs/promises",
+  "http",
+  "http2",
+  "https",
+  "inspector",
+  "inspector/promises",
+  "module",
+  "net",
+  "os",
+  "path",
+  "path/posix",
+  "path/win32",
+  "perf_hooks",
+  "process",
+  "punycode",
+  "querystring",
+  "quic",
+  "readline",
+  "readline/promises",
+  "repl",
+  "sea",
+  "sqlite",
+  "stream",
+  "stream/consumers",
+  "stream/promises",
+  "stream/web",
+  "string_decoder",
+  "sys",
+  "test",
+  "timers",
+  "timers/promises",
+  "tls",
+  "trace_events",
+  "tty",
+  "url",
+  "util",
+  "util/types",
+  "v8",
+  "vm",
+  "wasi",
+  "worker_threads",
+  "zlib",
+];
+
+export function isBuiltin(id: string): boolean {
+  const stripped = id.startsWith("node:") ? id.slice(5) : id;
+  if (builtinModules.includes(stripped)) return true;
+  const slash = stripped.indexOf("/");
+  if (slash !== -1) {
+    return builtinModules.includes(stripped.slice(0, slash));
+  }
+  return false;
+}
+
+export function createRequire(origin: string): (specifier: string) => unknown {
+  return function requireFrom(specifier: string): unknown {
+    throw new Error(`Cannot resolve module '${specifier}' from '${origin}'`);
+  };
+}
+
+export const _cache: Record<string, unknown> = {};
+
+export const _extensions: Record<string, unknown> = {
+  ".js": () => {},
+  ".json": () => {},
+  ".node": () => {},
+};
+
+export const _pathCache: Record<string, string> = {};
+
+export function _resolveFilename(
+  request: string,
+  _parent?: unknown,
+  _isMain?: boolean,
+  _options?: unknown,
+): string {
+  return request;
+}
+
+export function _nodeModulePaths(from: string): string[] {
+  const parts = from.split("/").filter(Boolean);
+  const paths: string[] = [];
+  for (let i = parts.length; i > 0; i--) {
+    const dir = "/" + parts.slice(0, i).join("/");
+    if (parts[i - 1] !== "node_modules") {
+      paths.push(dir + "/node_modules");
+    }
+  }
+  paths.push("/node_modules");
+  return paths;
+}
+
+export function _load(
+  request: string,
+  _parent?: unknown,
+  _isMain?: boolean,
+): unknown {
+  // wired up by ScriptEngine.buildResolver at runtime
+  throw new Error(`Cannot load module '${request}'`);
+}
+
+export function _findPath(
+  request: string,
+  _paths?: string[],
+  _isMain?: boolean,
+): string | false {
+  return request;
+}
+
+export function wrap(script: string): string {
+  return (
+    "(function (exports, require, module, __filename, __dirname) { " +
+    script +
+    "\n});"
+  );
+}
+
+export const wrapper = [
+  "(function (exports, require, module, __filename, __dirname) { ",
+  "\n});",
+];
+
+export function syncBuiltinESMExports(): void {
+}
+
+export function Module(this: any, id?: string, parent?: any) {
+  this.id = id || "";
+  this.filename = id || "";
+  this.loaded = false;
+  this.parent = parent || null;
+  this.children = [];
+  this.exports = {};
+  this.paths = [];
+}
+
+// Next.js accesses Module.prototype.require
+Module.prototype.require = function (specifier: string): unknown {
+  throw new Error(
+    `Cannot resolve module '${specifier}' from '${this.filename}'`,
+  );
+};
+
+Module.prototype.load = function (_filename: string): void {
+  this.loaded = true;
+};
+
+Module.prototype._compile = function (
+  _content: string,
+  _filename: string,
+): void {
+};
+
+Module.createRequire = createRequire;
+Module.builtinModules = builtinModules;
+Module.isBuiltin = isBuiltin;
+Module._cache = _cache;
+Module._extensions = _extensions;
+Module._pathCache = _pathCache;
+Module._resolveFilename = _resolveFilename;
+Module._nodeModulePaths = _nodeModulePaths;
+Module._load = _load;
+Module._findPath = _findPath;
+Module.syncBuiltinESMExports = syncBuiltinESMExports;
+Module.wrap = wrap;
+Module.wrapper = wrapper;
+Module.Module = Module; 
+Module.runMain = function () {}; 
+Module._preloadModules = function (_requests?: string[]) {}; 
+Module._initPaths = function () {}; 
+Module.globalPaths = ["/node_modules"];
+
+export default Module;