almostnode 0.1.0

package/src/shims/readline.ts

@@ -0,0 +1,110 @@
+/**
+ * readline shim - Terminal readline is not available in browser
+ * Provides stubs for common usage patterns
+ */
+
+import { EventEmitter } from './events';
+
+export interface ReadLineOptions {
+  input?: unknown;
+  output?: unknown;
+  terminal?: boolean;
+  prompt?: string;
+}
+
+export class Interface extends EventEmitter {
+  constructor(_options?: ReadLineOptions) {
+    super();
+  }
+
+  prompt(_preserveCursor?: boolean): void {
+    // No-op in browser
+  }
+
+  setPrompt(_prompt: string): void {
+    // No-op
+  }
+
+  getPrompt(): string {
+    return '';
+  }
+
+  question(_query: string, callback: (answer: string) => void): void {
+    // In browser, we can't get input - just call callback with empty
+    setTimeout(() => callback(''), 0);
+  }
+
+  pause(): this {
+    return this;
+  }
+
+  resume(): this {
+    return this;
+  }
+
+  close(): void {
+    this.emit('close');
+  }
+
+  write(_data: string, _key?: { ctrl?: boolean; name?: string }): void {
+    // No-op
+  }
+
+  line: string = '';
+  cursor: number = 0;
+
+  getCursorPos(): { rows: number; cols: number } {
+    return { rows: 0, cols: 0 };
+  }
+}
+
+export function createInterface(options?: ReadLineOptions): Interface {
+  return new Interface(options);
+}
+
+export function clearLine(_stream: unknown, _dir: number, _callback?: () => void): boolean {
+  return true;
+}
+
+export function clearScreenDown(_stream: unknown, _callback?: () => void): boolean {
+  return true;
+}
+
+export function cursorTo(_stream: unknown, _x: number, _y?: number, _callback?: () => void): boolean {
+  return true;
+}
+
+export function moveCursor(_stream: unknown, _dx: number, _dy: number, _callback?: () => void): boolean {
+  return true;
+}
+
+export function emitKeypressEvents(_stream: unknown, _interface?: Interface): void {
+  // No-op
+}
+
+// Promises API
+export const promises = {
+  createInterface: (options?: ReadLineOptions) => {
+    const rl = createInterface(options);
+    return {
+      question: (query: string) => new Promise<string>((resolve) => {
+        rl.question(query, resolve);
+      }),
+      close: () => rl.close(),
+      [Symbol.asyncIterator]: async function* () {
+        // No lines in browser
+      },
+    };
+  },
+};
+
+export default {
+  Interface,
+  createInterface,
+  clearLine,
+  clearScreenDown,
+  cursorTo,
+  moveCursor,
+  emitKeypressEvents,
+  promises,
+};

package/src/shims/rollup.ts

@@ -0,0 +1,80 @@
+/**
+ * Rollup shim - Uses @rollup/browser for browser-compatible Rollup
+ *
+ * Vite uses Rollup for bundling. The native Rollup package doesn't work
+ * in browsers, so we need to use @rollup/browser instead.
+ */
+
+// Rollup instance loaded from CDN
+let rollupInstance: unknown = null;
+let loadPromise: Promise<unknown> | null = null;
+
+/**
+ * Load Rollup from CDN
+ */
+async function loadRollup(): Promise<unknown> {
+  if (rollupInstance) return rollupInstance;
+  if (loadPromise) return loadPromise;
+
+  loadPromise = (async () => {
+    try {
+      // Load @rollup/browser from CDN
+      const rollup = await import(
+        /* @vite-ignore */
+        'https://esm.sh/@rollup/browser@4.9.0'
+      );
+      rollupInstance = rollup;
+      console.log('[rollup] Browser version loaded');
+      return rollup;
+    } catch (error) {
+      console.error('[rollup] Failed to load browser version:', error);
+      loadPromise = null;
+      throw error;
+    }
+  })();
+
+  return loadPromise;
+}
+
+// For synchronous require(), we need a stub that works before async load
+// This will be replaced when loadRollup() is called
+
+export const VERSION = '4.9.0';
+
+export async function rollup(options: unknown): Promise<unknown> {
+  const r = await loadRollup() as { rollup: (options: unknown) => Promise<unknown> };
+  return r.rollup(options);
+}
+
+export async function watch(options: unknown): Promise<unknown> {
+  const r = await loadRollup() as { watch: (options: unknown) => unknown };
+  return r.watch(options);
+}
+
+// Export a function to pre-load rollup
+export { loadRollup };
+
+// Define plugin context types that Vite expects
+export interface Plugin {
+  name: string;
+  [key: string]: unknown;
+}
+
+export interface PluginContext {
+  meta: { rollupVersion: string };
+  parse: (code: string) => unknown;
+  [key: string]: unknown;
+}
+
+// Stub for native module detection - this prevents the "unsupported platform" error
+export function getPackageBase(): string {
+  return '';
+}
+
+// Export default that matches Rollup's API
+export default {
+  VERSION,
+  rollup,
+  watch,
+  loadRollup,
+};

package/src/shims/sentry.ts

@@ -0,0 +1,133 @@
+/**
+ * Sentry SDK shim for browser-based runtime
+ * Provides no-op implementations since error tracking to Sentry isn't useful in our environment
+ */
+
+// No-op functions
+const noop = () => {};
+const noopPromise = () => Promise.resolve();
+
+// Scope class (no-op)
+class Scope {
+  setTag = noop;
+  setTags = noop;
+  setUser = noop;
+  setContext = noop;
+  setExtra = noop;
+  setExtras = noop;
+  setLevel = noop;
+  setTransactionName = noop;
+  setFingerprint = noop;
+  addBreadcrumb = noop;
+  clearBreadcrumbs = noop;
+  addEventProcessor = noop;
+  addAttachment = noop;
+  clear = noop;
+  update = () => this;
+  clone = () => new Scope();
+}
+
+// Hub class (no-op)
+class Hub {
+  getClient = () => undefined;
+  getScope = () => new Scope();
+  pushScope = () => new Scope();
+  popScope = noop;
+  withScope = (callback: (scope: Scope) => void) => callback(new Scope());
+  captureException = () => '';
+  captureMessage = () => '';
+  captureEvent = () => '';
+  addBreadcrumb = noop;
+  setUser = noop;
+  setTags = noop;
+  setTag = noop;
+  setExtra = noop;
+  setExtras = noop;
+  setContext = noop;
+}
+
+// Transaction (no-op)
+class Transaction {
+  name = '';
+  spanId = '';
+  traceId = '';
+  op = '';
+  finish = noop;
+  setTag = noop;
+  setData = noop;
+  setStatus = noop;
+  startChild = () => new Transaction();
+  toTraceparent = () => '';
+}
+
+// Current hub singleton
+const currentHub = new Hub();
+
+// Main exports
+export const init = noop;
+export const close = noopPromise;
+export const flush = noopPromise;
+export const captureException = () => '';
+export const captureMessage = () => '';
+export const captureEvent = () => '';
+export const addBreadcrumb = noop;
+export const setUser = noop;
+export const setTag = noop;
+export const setTags = noop;
+export const setExtra = noop;
+export const setExtras = noop;
+export const setContext = noop;
+export const configureScope = (callback: (scope: Scope) => void) => callback(new Scope());
+export const withScope = (callback: (scope: Scope) => void) => callback(new Scope());
+export const getCurrentHub = () => currentHub;
+export const getHubFromCarrier = () => currentHub;
+export const startTransaction = () => new Transaction();
+export const lastEventId = () => undefined;
+
+// Classes
+export { Scope, Hub };
+
+// Integrations (no-op)
+export const Integrations = {
+  Http: class {},
+  OnUncaughtException: class {},
+  OnUnhandledRejection: class {},
+  Console: class {},
+  Context: class {},
+  ContextLines: class {},
+  Modules: class {},
+  RequestData: class {},
+  LinkedErrors: class {},
+};
+
+// Node-specific exports
+export const Handlers = {
+  requestHandler: () => (_req: unknown, _res: unknown, next: () => void) => next(),
+  errorHandler: () => (_err: unknown, _req: unknown, _res: unknown, next: () => void) => next(),
+  tracingHandler: () => (_req: unknown, _res: unknown, next: () => void) => next(),
+};
+
+export default {
+  init,
+  close,
+  flush,
+  captureException,
+  captureMessage,
+  captureEvent,
+  addBreadcrumb,
+  setUser,
+  setTag,
+  setTags,
+  setExtra,
+  setExtras,
+  setContext,
+  configureScope,
+  withScope,
+  getCurrentHub,
+  startTransaction,
+  lastEventId,
+  Scope,
+  Hub,
+  Integrations,
+  Handlers,
+};