@scelar/nodepod 1.0.0

package/src/polyfills/path.ts

@@ -0,0 +1,206 @@
+// POSIX path operations polyfill
+
+
+// Path separator and delimiter constants
+export const sep = '/';
+export const delimiter = ':';
+
+export function normalize(inputPath: string): string {
+  if (!inputPath) return '.';
+
+  const rooted = inputPath.charAt(0) === '/';
+  const tokens = inputPath.split('/').filter(t => t.length > 0);
+  const stack: string[] = [];
+
+  for (const token of tokens) {
+    if (token === '..') {
+      if (stack.length > 0 && stack[stack.length - 1] !== '..') {
+        stack.pop();
+      } else if (!rooted) {
+        stack.push('..');
+      }
+    } else if (token !== '.') {
+      stack.push(token);
+    }
+  }
+
+  let output = stack.join('/');
+  if (rooted) {
+    output = '/' + output;
+  }
+  return output || '.';
+}
+
+export function join(...fragments: string[]): string {
+  if (fragments.length === 0) return '.';
+  const combined = fragments.filter(f => f !== '').join('/');
+  return normalize(combined);
+}
+
+// resolves right-to-left until an absolute path is formed
+export function resolve(...segments: string[]): string {
+  let accumulated = '';
+
+  for (let idx = segments.length - 1; idx >= 0; idx--) {
+    const segment = segments[idx];
+    if (!segment) continue;
+    accumulated = segment + (accumulated ? '/' + accumulated : '');
+    if (accumulated.charAt(0) === '/') break;
+  }
+
+  if (accumulated.charAt(0) !== '/') {
+    const workingDir =
+      typeof globalThis !== 'undefined' &&
+      globalThis.process &&
+      typeof globalThis.process.cwd === 'function'
+        ? globalThis.process.cwd()
+        : '/';
+    accumulated = workingDir + (accumulated ? '/' + accumulated : '');
+  }
+
+  return normalize(accumulated);
+}
+
+export function isAbsolute(targetPath: string): boolean {
+  return targetPath.charAt(0) === '/';
+}
+
+export function dirname(targetPath: string): string {
+  if (!targetPath) return '.';
+  const clean = normalize(targetPath);
+  const slashPos = clean.lastIndexOf('/');
+  if (slashPos < 0) return '.';
+  if (slashPos === 0) return '/';
+  return clean.substring(0, slashPos);
+}
+
+export function basename(targetPath: string, suffix?: string): string {
+  if (!targetPath) return '';
+  const clean = normalize(targetPath);
+  let name = clean.substring(clean.lastIndexOf('/') + 1);
+  if (suffix && name.endsWith(suffix)) {
+    name = name.substring(0, name.length - suffix.length);
+  }
+  return name;
+}
+
+export function extname(targetPath: string): string {
+  const name = basename(targetPath);
+  const dotPos = name.lastIndexOf('.');
+  if (dotPos <= 0) return '';
+  return name.substring(dotPos);
+}
+
+export function relative(fromPath: string, toPath: string): string {
+  const absFrom = resolve(fromPath);
+  const absTo = resolve(toPath);
+
+  if (absFrom === absTo) return '';
+
+  const partsFrom = absFrom.split('/').filter(Boolean);
+  const partsTo = absTo.split('/').filter(Boolean);
+
+  let shared = 0;
+  const limit = Math.min(partsFrom.length, partsTo.length);
+  while (shared < limit && partsFrom[shared] === partsTo[shared]) {
+    shared++;
+  }
+
+  const ascend = partsFrom.length - shared;
+  const descend = partsTo.slice(shared);
+
+  const pieces: string[] = [];
+  for (let i = 0; i < ascend; i++) {
+    pieces.push('..');
+  }
+  pieces.push(...descend);
+
+  return pieces.join('/') || '.';
+}
+
+export function parse(targetPath: string): {
+  root: string;
+  dir: string;
+  base: string;
+  ext: string;
+  name: string;
+} {
+  const clean = normalize(targetPath);
+  const rooted = isAbsolute(clean);
+  const directory = dirname(clean);
+  const base = basename(clean);
+  const extension = extname(clean);
+  const stem = base.substring(0, base.length - extension.length);
+
+  return {
+    root: rooted ? '/' : '',
+    dir: directory,
+    base,
+    ext: extension,
+    name: stem,
+  };
+}
+
+export function format(components: {
+  root?: string;
+  dir?: string;
+  base?: string;
+  ext?: string;
+  name?: string;
+}): string {
+  const directory = components.dir || components.root || '';
+  const filename = components.base || (components.name || '') + (components.ext || '');
+
+  if (!directory) return filename;
+  if (directory === components.root) return directory + filename;
+  return directory + '/' + filename;
+}
+
+// The posix namespace mirrors all path functions (this IS a POSIX implementation)
+export const posix = {
+  sep,
+  delimiter,
+  normalize,
+  join,
+  resolve,
+  isAbsolute,
+  dirname,
+  basename,
+  extname,
+  relative,
+  parse,
+  format,
+};
+
+// Win32 namespace provided as a stub; all operations delegate to POSIX logic
+export const win32 = {
+  sep: '\\',
+  delimiter: ';',
+  normalize,
+  join,
+  resolve,
+  isAbsolute,
+  dirname,
+  basename,
+  extname,
+  relative,
+  parse,
+  format,
+};
+
+export default {
+  sep,
+  delimiter,
+  normalize,
+  join,
+  resolve,
+  isAbsolute,
+  dirname,
+  basename,
+  extname,
+  relative,
+  parse,
+  format,
+  posix,
+  win32,
+};

package/src/polyfills/perf_hooks.ts

@@ -0,0 +1,102 @@
+// perf_hooks polyfill wrapping browser Performance API
+
+
+
+export const performance: Performance = globalThis.performance ?? ({
+  now: () => Date.now(),
+  timeOrigin: Date.now(),
+  mark: () => {},
+  measure: () => {},
+  getEntries: () => [],
+  getEntriesByName: () => [],
+  getEntriesByType: () => [],
+  clearMarks: () => {},
+  clearMeasures: () => {},
+  clearResourceTimings: () => {},
+} as unknown as Performance);
+
+
+export interface TimingEntryList {
+  getEntries(): PerformanceEntry[];
+  getEntriesByName(name: string, kind?: string): PerformanceEntry[];
+  getEntriesByType(kind: string): PerformanceEntry[];
+}
+
+export interface PerformanceObserver {
+  observe(cfg: { entryTypes?: string[]; type?: string }): void;
+  disconnect(): void;
+  takeRecords(): PerformanceEntry[];
+}
+
+export const PerformanceObserver = function PerformanceObserver(this: any, fn: (list: TimingEntryList) => void) {
+  if (!this) return;
+  this._fn = fn;
+  this._types = [];
+} as unknown as { new(fn: (list: TimingEntryList) => void): PerformanceObserver; prototype: any; supportedEntryTypes: string[] };
+
+PerformanceObserver.supportedEntryTypes = ['mark', 'measure', 'resource', 'navigation'];
+
+PerformanceObserver.prototype.observe = function observe(cfg: { entryTypes?: string[]; type?: string }): void {
+  this._types = cfg.entryTypes ?? (cfg.type ? [cfg.type] : []);
+};
+
+PerformanceObserver.prototype.disconnect = function disconnect(): void {
+  this._types = [];
+};
+
+PerformanceObserver.prototype.takeRecords = function takeRecords(): PerformanceEntry[] {
+  return [];
+};
+
+
+export interface TimingHistogram {
+  min: number;
+  max: number;
+  mean: number;
+  stddev: number;
+  percentiles: Map<number, number>;
+  exceeds: number;
+  reset(): void;
+  percentile(p: number): number;
+}
+
+export const TimingHistogram = function TimingHistogram(this: any) {
+  if (!this) return;
+  this.min = 0;
+  this.max = 0;
+  this.mean = 0;
+  this.stddev = 0;
+  this.percentiles = new Map<number, number>();
+  this.exceeds = 0;
+} as unknown as { new(): TimingHistogram; prototype: any };
+
+TimingHistogram.prototype.reset = function reset(): void {
+  this.min = 0;
+  this.max = 0;
+  this.mean = 0;
+  this.stddev = 0;
+  this.percentiles.clear();
+  this.exceeds = 0;
+};
+
+TimingHistogram.prototype.percentile = function percentile(p: number): number {
+  return this.percentiles.get(p) ?? 0;
+};
+
+export function createHistogram(): TimingHistogram {
+  return new TimingHistogram();
+}
+
+export function monitorEventLoopDelay(
+  _opts?: { resolution?: number }
+): TimingHistogram {
+  return new TimingHistogram();
+}
+
+
+export default {
+  performance,
+  PerformanceObserver,
+  createHistogram,
+  monitorEventLoopDelay,
+};