@holoscript/std 2.1.0 → 6.0.3

package/src/__tests__/string-decoupled.test.ts

@@ -0,0 +1,14 @@
+import { describe, it, expect } from 'vitest';
+
+// Auto-generated test for string-decoupled
+// Source: packages/std/src/string.ts
+
+describe('string-decoupled', () => {
+  it('should be defined', () => {
+    // TODO: Import and test string-decoupled
+  });
+
+  it('should have basic functionality', () => {
+    // TODO: Add meaningful tests for string-decoupled
+  });
+});

package/src/__tests__/string.test.ts

@@ -0,0 +1,164 @@
+import { describe, it, expect } from 'vitest';
+import {
+  isBlank,
+  isNotBlank,
+  capitalize,
+  titleCase,
+  camelCase,
+  pascalCase,
+  snakeCase,
+  kebabCase,
+  constantCase,
+} from '../string.js';
+
+describe('isBlank', () => {
+  it('should return true for empty string', () => {
+    expect(isBlank('')).toBe(true);
+  });
+
+  it('should return true for whitespace only', () => {
+    expect(isBlank('   ')).toBe(true);
+    expect(isBlank('\t\n')).toBe(true);
+  });
+
+  it('should return false for non-empty string', () => {
+    expect(isBlank('hello')).toBe(false);
+    expect(isBlank(' hello ')).toBe(false);
+  });
+});
+
+describe('isNotBlank', () => {
+  it('should return false for empty string', () => {
+    expect(isNotBlank('')).toBe(false);
+  });
+
+  it('should return false for whitespace only', () => {
+    expect(isNotBlank('   ')).toBe(false);
+  });
+
+  it('should return true for non-empty string', () => {
+    expect(isNotBlank('hello')).toBe(true);
+  });
+});
+
+describe('capitalize', () => {
+  it('should capitalize first letter', () => {
+    expect(capitalize('hello')).toBe('Hello');
+  });
+
+  it('should handle empty string', () => {
+    expect(capitalize('')).toBe('');
+  });
+
+  it('should handle already capitalized', () => {
+    expect(capitalize('Hello')).toBe('Hello');
+  });
+
+  it('should handle single character', () => {
+    expect(capitalize('a')).toBe('A');
+  });
+});
+
+describe('titleCase', () => {
+  it('should capitalize each word', () => {
+    expect(titleCase('hello world')).toBe('Hello World');
+  });
+
+  it('should handle multiple spaces', () => {
+    expect(titleCase('hello  world')).toBe('Hello World');
+  });
+
+  it('should handle single word', () => {
+    expect(titleCase('hello')).toBe('Hello');
+  });
+});
+
+describe('camelCase', () => {
+  it('should convert space-separated to camelCase', () => {
+    expect(camelCase('hello world')).toBe('helloWorld');
+  });
+
+  it('should convert kebab-case to camelCase', () => {
+    expect(camelCase('hello-world')).toBe('helloWorld');
+  });
+
+  it('should convert snake_case to camelCase', () => {
+    expect(camelCase('hello_world')).toBe('helloWorld');
+  });
+
+  it('should lowercase first letter of PascalCase', () => {
+    expect(camelCase('HelloWorld')).toBe('helloWorld');
+  });
+
+  it('should handle empty string', () => {
+    expect(camelCase('')).toBe('');
+  });
+});
+
+describe('pascalCase', () => {
+  it('should convert space-separated to PascalCase', () => {
+    expect(pascalCase('hello world')).toBe('HelloWorld');
+  });
+
+  it('should convert kebab-case to PascalCase', () => {
+    expect(pascalCase('hello-world')).toBe('HelloWorld');
+  });
+
+  it('should convert snake_case to PascalCase', () => {
+    expect(pascalCase('hello_world')).toBe('HelloWorld');
+  });
+
+  it('should handle empty string', () => {
+    expect(pascalCase('')).toBe('');
+  });
+});
+
+describe('snakeCase', () => {
+  it('should convert space-separated to snake_case', () => {
+    expect(snakeCase('hello world')).toBe('hello_world');
+  });
+
+  it('should convert camelCase to snake_case', () => {
+    expect(snakeCase('helloWorld')).toBe('hello_world');
+  });
+
+  it('should convert PascalCase to snake_case', () => {
+    expect(snakeCase('HelloWorld')).toBe('hello_world');
+  });
+
+  it('should convert kebab-case to snake_case', () => {
+    expect(snakeCase('hello-world')).toBe('hello_world');
+  });
+});
+
+describe('kebabCase', () => {
+  it('should convert space-separated to kebab-case', () => {
+    expect(kebabCase('hello world')).toBe('hello-world');
+  });
+
+  it('should convert camelCase to kebab-case', () => {
+    expect(kebabCase('helloWorld')).toBe('hello-world');
+  });
+
+  it('should convert PascalCase to kebab-case', () => {
+    expect(kebabCase('HelloWorld')).toBe('hello-world');
+  });
+
+  it('should convert snake_case to kebab-case', () => {
+    expect(kebabCase('hello_world')).toBe('hello-world');
+  });
+});
+
+describe('constantCase', () => {
+  it('should convert to SCREAMING_SNAKE_CASE', () => {
+    expect(constantCase('hello world')).toBe('HELLO_WORLD');
+  });
+
+  it('should convert camelCase to SCREAMING_SNAKE_CASE', () => {
+    expect(constantCase('helloWorld')).toBe('HELLO_WORLD');
+  });
+
+  it('should convert kebab-case to SCREAMING_SNAKE_CASE', () => {
+    expect(constantCase('hello-world')).toBe('HELLO_WORLD');
+  });
+});

package/src/__tests__/time.test.ts

@@ -0,0 +1,110 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { now, hrTime, sleep, withTimeout } from '../time.js';
+
+describe('now', () => {
+  it('should return current timestamp in milliseconds', () => {
+    const before = Date.now();
+    const result = now();
+    const after = Date.now();
+
+    expect(result).toBeGreaterThanOrEqual(before);
+    expect(result).toBeLessThanOrEqual(after);
+  });
+
+  it('should return a number', () => {
+    expect(typeof now()).toBe('number');
+  });
+});
+
+describe('hrTime', () => {
+  it('should return high-resolution timestamp', () => {
+    const result = hrTime();
+    expect(typeof result).toBe('number');
+    expect(result).toBeGreaterThanOrEqual(0);
+  });
+
+  it('should increase over time', async () => {
+    const t1 = hrTime();
+    await sleep(10);
+    const t2 = hrTime();
+    expect(t2).toBeGreaterThan(t1);
+  });
+});
+
+describe('sleep', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('should return a promise', () => {
+    const result = sleep(100);
+    expect(result).toBeInstanceOf(Promise);
+    vi.runAllTimers();
+  });
+
+  it('should resolve after specified time', async () => {
+    let resolved = false;
+    const promise = sleep(1000).then(() => {
+      resolved = true;
+    });
+
+    expect(resolved).toBe(false);
+
+    vi.advanceTimersByTime(500);
+    await Promise.resolve();
+    expect(resolved).toBe(false);
+
+    vi.advanceTimersByTime(500);
+    await promise;
+    expect(resolved).toBe(true);
+  });
+});
+
+describe('withTimeout', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('should resolve if function completes before timeout', async () => {
+    const fn = async () => {
+      await sleep(50);
+      return 'success';
+    };
+
+    const promise = withTimeout(fn, 1000);
+    vi.advanceTimersByTime(50);
+    await vi.runAllTimersAsync();
+
+    const result = await promise;
+    expect(result).toBe('success');
+  });
+
+  it('should reject with Timeout error if function takes too long', async () => {
+    const fn = async () => {
+      await sleep(2000);
+      return 'success';
+    };
+
+    const promise = withTimeout(fn, 100);
+    vi.advanceTimersByTime(100);
+
+    await expect(promise).rejects.toThrow('Timeout');
+  });
+});
+
+describe('time utilities - real timers', () => {
+  it('sleep should actually wait (short duration)', async () => {
+    const start = Date.now();
+    await sleep(50);
+    const elapsed = Date.now() - start;
+    expect(elapsed).toBeGreaterThanOrEqual(40); // Allow some tolerance
+  });
+});

package/src/collections.ts

@@ -825,10 +825,16 @@ export class PriorityQueue<T> {
       const rightChild = 2 * index + 2;
       let smallest = index;
 
-      if (leftChild < this.heap.length && this.compareFn(this.heap[leftChild].priority, this.heap[smallest].priority) < 0) {
+      if (
+        leftChild < this.heap.length &&
+        this.compareFn(this.heap[leftChild].priority, this.heap[smallest].priority) < 0
+      ) {
         smallest = leftChild;
       }
-      if (rightChild < this.heap.length && this.compareFn(this.heap[rightChild].priority, this.heap[smallest].priority) < 0) {
+      if (
+        rightChild < this.heap.length &&
+        this.compareFn(this.heap[rightChild].priority, this.heap[smallest].priority) < 0
+      ) {
         smallest = rightChild;
       }
 

package/src/events.ts

@@ -0,0 +1,88 @@
+/**
+ * @holoscript/std — Events Module
+ *
+ * Provides a typed event bus for HoloScript compositions.
+ * Supports emit, on, once, off, and wildcard listeners.
+ *
+ * @version 0.2.0
+ * @module @holoscript/std/events
+ */
+
+export type EventHandler<T = any> = (data: T) => void;
+
+interface Listener {
+  handler: EventHandler;
+  once: boolean;
+}
+
+export class EventBus {
+  private listeners: Map<string, Listener[]> = new Map();
+  private wildcardListeners: Listener[] = [];
+
+  /** Register an event listener. */
+  on<T = any>(event: string, handler: EventHandler<T>): () => void {
+    if (!this.listeners.has(event)) this.listeners.set(event, []);
+    const listener: Listener = { handler, once: false };
+    this.listeners.get(event)!.push(listener);
+    return () => this.off(event, handler);
+  }
+
+  /** Register a one-time event listener. */
+  once<T = any>(event: string, handler: EventHandler<T>): () => void {
+    if (!this.listeners.has(event)) this.listeners.set(event, []);
+    const listener: Listener = { handler, once: true };
+    this.listeners.get(event)!.push(listener);
+    return () => this.off(event, handler);
+  }
+
+  /** Remove an event listener. */
+  off(event: string, handler: EventHandler): void {
+    const list = this.listeners.get(event);
+    if (!list) return;
+    this.listeners.set(
+      event,
+      list.filter((l) => l.handler !== handler)
+    );
+  }
+
+  /** Emit an event to all registered listeners. */
+  emit<T = any>(event: string, data?: T): void {
+    // Fire specific listeners
+    const list = this.listeners.get(event);
+    if (list) {
+      const remaining: Listener[] = [];
+      for (const l of list) {
+        l.handler(data);
+        if (!l.once) remaining.push(l);
+      }
+      this.listeners.set(event, remaining);
+    }
+    // Fire wildcard listeners
+    for (const l of this.wildcardListeners) {
+      l.handler({ event, data });
+    }
+  }
+
+  /** Listen to all events. */
+  onAny(handler: EventHandler<{ event: string; data: any }>): () => void {
+    const listener: Listener = { handler, once: false };
+    this.wildcardListeners.push(listener);
+    return () => {
+      this.wildcardListeners = this.wildcardListeners.filter((l) => l !== listener);
+    };
+  }
+
+  /** Remove all listeners. */
+  clear(): void {
+    this.listeners.clear();
+    this.wildcardListeners = [];
+  }
+
+  /** Get count of listeners for an event (or all events). */
+  listenerCount(event?: string): number {
+    if (event) return (this.listeners.get(event) || []).length;
+    let total = this.wildcardListeners.length;
+    for (const [, list] of this.listeners) total += list.length;
+    return total;
+  }
+}

package/src/index.ts

@@ -2,25 +2,62 @@
  * @holoscript/std - Standard Library for HoloScript Plus
  *
  * Provides core types, math utilities, collections, string operations,
- * and time management for HoloScript Plus programs.
+ * time management, spatial math, physics primitives, materials, and events
+ * for HoloScript Plus programs.
  *
  * @example
  * ```hsplus
- * import { Vec3, List, sleep } from "@holoscript/std";
+ * import { Vec3, createPBRMaterial, EventBus } from "@holoscript/std";
  *
  * let position = Vec3(0, 1, 0);
- * let items = List.of(1, 2, 3).map(n => n * 2);
- *
- * async fn main() {
- *   await sleep(1000);
- *   print("Done!");
- * }
+ * let steel = createPBRMaterial("Steel", "metal");
+ * let bus = new EventBus();
  * ```
  */
 
 // Re-export everything from types.js
 export * from './types.js';
 
+// Spatial math (v4.2)
+export {
+  Vec3,
+  Quaternion,
+  Transform,
+  Ray,
+  AABB,
+  distance,
+  lerp as spatialLerp,
+  clamp as spatialClamp,
+  degToRad as spatialDegToRad,
+  radToDeg as spatialRadToDeg,
+} from './spatial.js';
+
+// Physics primitives (v4.2)
+export {
+  createBoxCollider,
+  createSphereCollider,
+  createCapsuleCollider,
+  createRigidbody,
+} from './physics.js';
+export type {
+  ColliderConfig,
+  ColliderShapeType,
+  RigidbodyConfig,
+  ForceFieldConfig,
+  ForceFieldType,
+  JointConfig,
+  JointType,
+  RaycastHit,
+} from './physics.js';
+
+// Materials (v4.2)
+export { MATERIAL_PRESETS, createPBRMaterial } from './materials.js';
+export type { PBRMaterial, UnlitMaterial, TextureMapType, TextureConfig } from './materials.js';
+
+// Events (v4.2)
+export { EventBus } from './events.js';
+export type { EventHandler } from './events.js';
+
 // Math utilities - export objects from math.ts
 export {
   // Constants
@@ -120,8 +157,114 @@ export {
   wordWrap,
   levenshtein,
   similarity,
+  extractTraits,
 } from './string.js';
 
+// Economic primitives (v4.3)
+export {
+  // Tradeable
+  generateTxHash,
+  executeTrade,
+  // Depreciation
+  calculateDepreciation,
+  depreciatedValue,
+  isDestroyed,
+  calculateRepairCost,
+  DEFAULT_DEPRECIATION,
+  // Bonding curves
+  bondingCurvePrice,
+  bondingCurveBuyCost,
+  bondingCurveSellRefund,
+  spatialPrice,
+  DEFAULT_BONDING_CURVE,
+  // Wealth taxation
+  calculateTaxRate,
+  calculateTaxAmount,
+  calculateRedistribution,
+  DEFAULT_WEALTH_TAX,
+  // PID control
+  createPIDState,
+  updatePID,
+  createDualLoopPIDState,
+  updateDualLoopPID,
+  DEFAULT_PID,
+  // Faucet-sink tracking
+  createFaucetSinkMetrics,
+  recordFaucet,
+  recordSink,
+  resetMetricsPeriod,
+} from './traits/EconomicPrimitives.js';
+export type {
+  Currency,
+  AgentID,
+  EconomicResult,
+  EconomicError,
+  EconomicPermission,
+  OwnershipRecord,
+  TransferRecord,
+  DepreciationConfig,
+  BondingCurveType,
+  BondingCurveConfig,
+  WealthTaxConfig,
+  PIDConfig,
+  PIDState,
+  DualLoopPIDConfig,
+  DualLoopPIDState,
+  FaucetSinkMetrics,
+} from './traits/EconomicPrimitives.js';
+
+// Economic traits (v4.3)
+export {
+  EconomicTraits,
+  getEconomicTraitNames,
+  getEconomicTrait,
+  validateTraitComposition,
+  getRequiredPermissions,
+} from './traits/EconomicTraits.js';
+export type { EconomicTraitDefinition } from './traits/EconomicTraits.js';
+
+// SimulationLab primitives (v4.3)
+export {
+  // Statistics
+  mean,
+  variance,
+  standardDeviation,
+  standardError,
+  cohensD,
+  // Statistical tests
+  tTest,
+  oneSampleTTest,
+  mannWhitneyU,
+  chiSquaredTest,
+  // Parameter sweeps
+  expandSweep,
+  generateSweepCombinations,
+  isParameterRange,
+  // Metric aggregation
+  extractMetric,
+  groupByParameter,
+  summarizeMetrics,
+} from './traits/SimulationLabPrimitives.js';
+export type {
+  Hypothesis,
+  HypothesisDirection,
+  SimulationStatus,
+  ParameterRange,
+  ParameterSet,
+  ParameterSweep,
+  SimulationMetrics,
+  StatisticalResult,
+  ExperimentResult,
+} from './traits/SimulationLabPrimitives.js';
+
+// SimulationLab traits (v4.3)
+export {
+  SimulationLabTraits,
+  getSimulationTraitNames,
+  getSimulationTrait,
+} from './traits/SimulationLabTraits.js';
+export type { SimulationTraitDefinition } from './traits/SimulationLabTraits.js';
+
 // Time utilities
 export {
   now,
@@ -178,7 +321,10 @@ export function assert(condition: boolean, message?: string): asserts condition
 /**
  * Assert a value is not null or undefined
  */
-export function assertDefined<T>(value: T | null | undefined, message?: string): asserts value is T {
+export function assertDefined<T>(
+  value: T | null | undefined,
+  message?: string
+): asserts value is T {
   if (value === null || value === undefined) {
     throw new Error(message ?? 'Value is null or undefined');
   }
@@ -266,7 +412,7 @@ export function equals(a: unknown, b: unknown): boolean {
     return true;
   }
 
-  const keysA = Object.keys(a as object);
+  const keysA = Object.keys(a);
   const keysB = Object.keys(b as object);
   if (keysA.length !== keysB.length) return false;
 
@@ -299,7 +445,11 @@ export function pipe(value: unknown, ...fns: ((x: unknown) => unknown)[]): unkno
 export function compose<A>(): (a: A) => A;
 export function compose<A, B>(fn1: (a: A) => B): (a: A) => B;
 export function compose<A, B, C>(fn2: (b: B) => C, fn1: (a: A) => B): (a: A) => C;
-export function compose<A, B, C, D>(fn3: (c: C) => D, fn2: (b: B) => C, fn1: (a: A) => B): (a: A) => D;
+export function compose<A, B, C, D>(
+  fn3: (c: C) => D,
+  fn2: (b: B) => C,
+  fn1: (a: A) => B
+): (a: A) => D;
 export function compose(...fns: ((x: unknown) => unknown)[]): (x: unknown) => unknown {
   return (value: unknown) => fns.reduceRight((acc, fn) => fn(acc), value);
 }