@holoscript/core 1.0.0-alpha.1 → 2.0.0

package/src/types/AdvancedTypeSystem.js

@@ -0,0 +1,226 @@
+/**
+ * @holoscript/core Advanced Type System
+ *
+ * Union types, generics, type inference, exhaustiveness checking
+ */
+/**
+ * Type inference engine
+ */
+export class TypeInferenceEngine {
+    constructor() {
+        this.typeEnvironment = new Map();
+        this.genericTypeVars = new Map();
+    }
+    /**
+     * Infer type from value
+     */
+    inferType(value) {
+        if (typeof value === 'number') {
+            return { kind: 'primitive', name: 'number' };
+        }
+        if (typeof value === 'string') {
+            return { kind: 'primitive', name: 'string' };
+        }
+        if (typeof value === 'boolean') {
+            return { kind: 'primitive', name: 'boolean' };
+        }
+        if (Array.isArray(value)) {
+            const elementType = value.length > 0 ? this.inferType(value[0]) : { kind: 'primitive', name: 'void' };
+            return { kind: 'array', elementType };
+        }
+        return { kind: 'primitive', name: 'void' };
+    }
+    /**
+     * Check type compatibility
+     */
+    isAssignableTo(from, to) {
+        // Same type
+        if (JSON.stringify(from) === JSON.stringify(to))
+            return true;
+        // Union type includes from
+        if (to.kind === 'union') {
+            return to.members.some((m) => this.isAssignableTo(from, m));
+        }
+        // Intersection type all match
+        if (from.kind === 'intersection') {
+            return from.members.every((m) => this.isAssignableTo(m, to));
+        }
+        // Array covariance
+        if (from.kind === 'array' && to.kind === 'array') {
+            return this.isAssignableTo(from.elementType, to.elementType);
+        }
+        return false;
+    }
+    /**
+     * Unify types (for generics)
+     */
+    unify(t1, t2) {
+        const substitutions = new Map();
+        // If t1 is a type variable
+        if (t1.kind === 'custom' && this.isTypeVariable(t1.name)) {
+            substitutions.set(t1.name, t2);
+            return substitutions;
+        }
+        // Structural unification
+        if (t1.kind === 'array' && t2.kind === 'array') {
+            return this.unify(t1.elementType, t2.elementType);
+        }
+        if (t1.kind === 'generic' && t2.kind === 'generic') {
+            if (t1.name === t2.name && t1.typeArgs.length === t2.typeArgs.length) {
+                for (let i = 0; i < t1.typeArgs.length; i++) {
+                    const unified = this.unify(t1.typeArgs[i], t2.typeArgs[i]);
+                    for (const [k, v] of unified) {
+                        substitutions.set(k, v);
+                    }
+                }
+            }
+        }
+        return substitutions;
+    }
+    isTypeVariable(name) {
+        return /^[A-Z]$/.test(name); // Single uppercase letter is type var
+    }
+    /**
+     * Resolve generic type with type arguments
+     */
+    resolveGeneric(generic, concreteTypes) {
+        const substitutions = new Map();
+        for (let i = 0; i < generic.typeArgs.length; i++) {
+            if (generic.typeArgs[i].kind === 'custom') {
+                substitutions.set(generic.typeArgs[i].name, concreteTypes[i]);
+            }
+        }
+        return this.substitute(generic, substitutions);
+    }
+    substitute(type, subs) {
+        if (type.kind === 'custom' && subs.has(type.name)) {
+            return subs.get(type.name);
+        }
+        if (type.kind === 'array') {
+            return {
+                kind: 'array',
+                elementType: this.substitute(type.elementType, subs),
+            };
+        }
+        if (type.kind === 'union') {
+            return {
+                kind: 'union',
+                members: type.members.map((m) => this.substitute(m, subs)),
+            };
+        }
+        return type;
+    }
+}
+/**
+ * Exhaustiveness checker for match statements
+ */
+export class ExhaustivenessChecker {
+    /**
+     * Check if all union members are covered in match statement
+     */
+    checkMatch(unionType, casePatterns) {
+        const patterns = new Set(casePatterns.map((p) => p.toLowerCase()));
+        const uncovered = [];
+        for (const member of unionType.members) {
+            const caseName = this.getCaseName(member);
+            if (!patterns.has(caseName.toLowerCase()) && caseName !== '_') {
+                uncovered.push(caseName);
+            }
+        }
+        return {
+            isExhaustive: uncovered.length === 0 || patterns.has('_'),
+            uncoveredCases: uncovered,
+        };
+    }
+    getCaseName(type) {
+        if (type.kind === 'literal') {
+            return String(type.value);
+        }
+        if (type.kind === 'custom') {
+            return type.name;
+        }
+        return type.kind;
+    }
+}
+/**
+ * Type checker for HoloScript+
+ */
+export class AdvancedTypeChecker {
+    constructor() {
+        this.types = new Map();
+        this.inference = new TypeInferenceEngine();
+        this.exhaustiveness = new ExhaustivenessChecker();
+        // Register built-in types
+        this.registerBuiltins();
+    }
+    registerBuiltins() {
+        this.types.set('Vector3', {
+            kind: 'custom',
+            name: 'Vector3',
+            properties: new Map([
+                ['x', { kind: 'primitive', name: 'number' }],
+                ['y', { kind: 'primitive', name: 'number' }],
+                ['z', { kind: 'primitive', name: 'number' }],
+            ]),
+            methods: new Map(),
+        });
+        this.types.set('Transform', {
+            kind: 'custom',
+            name: 'Transform',
+            properties: new Map([
+                ['position', this.types.get('Vector3')],
+                ['rotation', this.types.get('Vector3')],
+                ['scale', this.types.get('Vector3')],
+            ]),
+            methods: new Map(),
+        });
+    }
+    /**
+     * Register a new type
+     */
+    registerType(name, type) {
+        this.types.set(name, type);
+    }
+    /**
+     * Get registered type
+     */
+    getType(name) {
+        return this.types.get(name);
+    }
+    /**
+     * Check union exhaustiveness
+     */
+    checkUnionExhaustiveness(unionType, cases) {
+        return this.exhaustiveness.checkMatch(unionType, cases);
+    }
+    /**
+     * Check type assignment
+     */
+    checkAssignment(from, to) {
+        if (this.inference.isAssignableTo(from, to)) {
+            return { valid: true };
+        }
+        return {
+            valid: false,
+            error: `Type '${this.formatType(from)}' is not assignable to '${this.formatType(to)}'`,
+        };
+    }
+    formatType(type) {
+        switch (type.kind) {
+            case 'primitive':
+                return type.name;
+            case 'array':
+                return `${this.formatType(type.elementType)}[]`;
+            case 'union':
+                return type.members.map((m) => this.formatType(m)).join(' | ');
+            case 'intersection':
+                return type.members.map((m) => this.formatType(m)).join(' & ');
+            case 'custom':
+                return type.name;
+            case 'literal':
+                return JSON.stringify(type.value);
+            default:
+                return 'unknown';
+        }
+    }
+}

package/src/types/AdvancedTypeSystem.ts

@@ -0,0 +1,494 @@
+/**
+ * @holoscript/core Advanced Type System
+ *
+ * Union types, generics, type inference, exhaustiveness checking
+ */
+
+export type HoloScriptType =
+  | PrimitiveType
+  | ArrayType
+  | UnionType
+  | IntersectionType
+  | GenericType
+  | LiteralType
+  | CustomType;
+
+/**
+ * Primitive types
+ */
+export type PrimitiveTypeName = 'number' | 'string' | 'boolean' | 'void';
+
+export interface PrimitiveType {
+  kind: 'primitive';
+  name: PrimitiveTypeName;
+}
+
+/**
+ * Array type: T[]
+ */
+export interface ArrayType {
+  kind: 'array';
+  elementType: HoloScriptType;
+}
+
+/**
+ * Union type: A | B | C
+ */
+export interface UnionType {
+  kind: 'union';
+  members: HoloScriptType[];
+}
+
+/**
+ * Intersection type: A & B
+ */
+export interface IntersectionType {
+  kind: 'intersection';
+  members: HoloScriptType[];
+}
+
+/**
+ * Generic type: Container<T>
+ */
+export interface GenericType {
+  kind: 'generic';
+  name: string;
+  typeArgs: HoloScriptType[];
+}
+
+/**
+ * Literal type: "idle" | "moving"
+ */
+export interface LiteralType {
+  kind: 'literal';
+  value: string | number | boolean;
+}
+
+/**
+ * Custom type: User-defined types
+ */
+export interface CustomType {
+  kind: 'custom';
+  name: string;
+  properties: Map<string, HoloScriptType>;
+  methods: Map<string, FunctionType>;
+}
+
+/**
+ * Function type
+ */
+export interface FunctionType {
+  kind: 'function';
+  parameters: { name: string; type: HoloScriptType }[];
+  returnType: HoloScriptType;
+}
+
+/**
+ * Type inference engine
+ */
+export class TypeInferenceEngine {
+  // Reserved for future type environment tracking
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  // private typeEnvironment: Map<string, HoloScriptType> = new Map();
+  // private genericTypeVars: Map<string, HoloScriptType> = new Map();
+
+  /**
+   * Infer type from value
+   */
+  inferType(value: any): HoloScriptType {
+    if (typeof value === 'number') {
+      return { kind: 'primitive', name: 'number' };
+    }
+    if (typeof value === 'string') {
+      return { kind: 'primitive', name: 'string' };
+    }
+    if (typeof value === 'boolean') {
+      return { kind: 'primitive', name: 'boolean' };
+    }
+    if (Array.isArray(value)) {
+      const elementType: HoloScriptType = value.length > 0 ? this.inferType(value[0]) : { kind: 'primitive', name: 'void' };
+      return { kind: 'array', elementType } as ArrayType;
+    }
+    return { kind: 'primitive', name: 'void' };
+  }
+
+  /**
+   * Check type compatibility
+   */
+  isAssignableTo(from: HoloScriptType, to: HoloScriptType): boolean {
+    // Same type
+    if (JSON.stringify(from) === JSON.stringify(to)) return true;
+
+    // Union type includes from
+    if (to.kind === 'union') {
+      return to.members.some((m) => this.isAssignableTo(from, m));
+    }
+
+    // Intersection type all match
+    if (from.kind === 'intersection') {
+      return from.members.every((m) => this.isAssignableTo(m, to));
+    }
+
+    // Array covariance
+    if (from.kind === 'array' && to.kind === 'array') {
+      return this.isAssignableTo(from.elementType, to.elementType);
+    }
+
+    return false;
+  }
+
+  /**
+   * Unify types (for generics)
+   */
+  unify(t1: HoloScriptType, t2: HoloScriptType): Map<string, HoloScriptType> {
+    const substitutions = new Map<string, HoloScriptType>();
+
+    // If t1 is a type variable
+    if (t1.kind === 'custom' && this.isTypeVariable(t1.name)) {
+      substitutions.set(t1.name, t2);
+      return substitutions;
+    }
+
+    // Structural unification
+    if (t1.kind === 'array' && t2.kind === 'array') {
+      return this.unify(t1.elementType, t2.elementType);
+    }
+
+    if (t1.kind === 'generic' && t2.kind === 'generic') {
+      if (t1.name === t2.name && t1.typeArgs.length === t2.typeArgs.length) {
+        for (let i = 0; i < t1.typeArgs.length; i++) {
+          const unified = this.unify(t1.typeArgs[i], t2.typeArgs[i]);
+          for (const [k, v] of unified) {
+            substitutions.set(k, v);
+          }
+        }
+      }
+    }
+
+    return substitutions;
+  }
+
+  private isTypeVariable(name: string): boolean {
+    return /^[A-Z]$/.test(name); // Single uppercase letter is type var
+  }
+
+  /**
+   * Resolve generic type with type arguments
+   */
+  resolveGeneric(generic: GenericType, concreteTypes: HoloScriptType[]): HoloScriptType {
+    const substitutions = new Map<string, HoloScriptType>();
+
+    for (let i = 0; i < generic.typeArgs.length; i++) {
+      if (generic.typeArgs[i].kind === 'custom') {
+        substitutions.set((generic.typeArgs[i] as CustomType).name, concreteTypes[i]);
+      }
+    }
+
+    return this.substitute(generic, substitutions);
+  }
+
+  private substitute(type: HoloScriptType, subs: Map<string, HoloScriptType>): HoloScriptType {
+    if (type.kind === 'custom' && subs.has((type as CustomType).name)) {
+      return subs.get((type as CustomType).name)!;
+    }
+
+    if (type.kind === 'array') {
+      return {
+        kind: 'array',
+        elementType: this.substitute((type as ArrayType).elementType, subs),
+      };
+    }
+
+    if (type.kind === 'union') {
+      return {
+        kind: 'union',
+        members: (type as UnionType).members.map((m) => this.substitute(m, subs)),
+      };
+    }
+
+    return type;
+  }
+}
+
+/**
+ * Exhaustiveness checker for match statements
+ */
+export class ExhaustivenessChecker {
+  /**
+   * Check if all union members are covered in match statement
+   */
+  checkMatch(unionType: UnionType, casePatterns: string[]): {
+    isExhaustive: boolean;
+    uncoveredCases: string[];
+  } {
+    const patterns = new Set(casePatterns.map((p) => p.toLowerCase()));
+
+    const uncovered: string[] = [];
+    for (const member of unionType.members) {
+      const caseName = this.getCaseName(member);
+      if (!patterns.has(caseName.toLowerCase()) && caseName !== '_') {
+        uncovered.push(caseName);
+      }
+    }
+
+    return {
+      isExhaustive: uncovered.length === 0 || patterns.has('_'),
+      uncoveredCases: uncovered,
+    };
+  }
+
+  private getCaseName(type: HoloScriptType): string {
+    if (type.kind === 'literal') {
+      return String((type as LiteralType).value);
+    }
+    if (type.kind === 'custom') {
+      return (type as CustomType).name;
+    }
+    return type.kind;
+  }
+}
+
+/**
+ * Type checker for HoloScript+
+ */
+export class AdvancedTypeChecker {
+  private inference: TypeInferenceEngine;
+  private exhaustiveness: ExhaustivenessChecker;
+  private types: Map<string, HoloScriptType> = new Map();
+
+  constructor() {
+    this.inference = new TypeInferenceEngine();
+    this.exhaustiveness = new ExhaustivenessChecker();
+
+    // Register built-in types
+    this.registerBuiltins();
+  }
+
+  private registerBuiltins(): void {
+    this.types.set('Vector3', {
+      kind: 'custom',
+      name: 'Vector3',
+      properties: new Map([
+        ['x', { kind: 'primitive', name: 'number' }],
+        ['y', { kind: 'primitive', name: 'number' }],
+        ['z', { kind: 'primitive', name: 'number' }],
+      ]),
+      methods: new Map(),
+    });
+
+    this.types.set('Transform', {
+      kind: 'custom',
+      name: 'Transform',
+      properties: new Map([
+        ['position', this.types.get('Vector3')!],
+        ['rotation', this.types.get('Vector3')!],
+        ['scale', this.types.get('Vector3')!],
+      ]),
+      methods: new Map(),
+    });
+  }
+
+  /**
+   * Register a new type
+   */
+  registerType(name: string, type: HoloScriptType): void {
+    this.types.set(name, type);
+  }
+
+  /**
+   * Get registered type
+   */
+  getType(name: string): HoloScriptType | undefined {
+    return this.types.get(name);
+  }
+
+  /**
+   * Check union exhaustiveness
+   */
+  checkUnionExhaustiveness(
+    unionType: UnionType,
+    cases: string[]
+  ): { isExhaustive: boolean; uncoveredCases: string[] } {
+    return this.exhaustiveness.checkMatch(unionType, cases);
+  }
+
+  /**
+   * Check type assignment
+   */
+  checkAssignment(from: HoloScriptType, to: HoloScriptType): { valid: boolean; error?: string } {
+    if (this.inference.isAssignableTo(from, to)) {
+      return { valid: true };
+    }
+
+    return {
+      valid: false,
+      error: `Type '${this.formatType(from)}' is not assignable to '${this.formatType(to)}'`,
+    };
+  }
+
+  private formatType(type: HoloScriptType): string {
+    switch (type.kind) {
+      case 'primitive':
+        return (type as PrimitiveType).name;
+      case 'array':
+        return `${this.formatType((type as ArrayType).elementType)}[]`;
+      case 'union':
+        return (type as UnionType).members.map((m) => this.formatType(m)).join(' | ');
+      case 'intersection':
+        return (type as IntersectionType).members.map((m) => this.formatType(m)).join(' & ');
+      case 'custom':
+        return (type as CustomType).name;
+      case 'literal':
+        return JSON.stringify((type as LiteralType).value);
+      default:
+        return 'unknown';
+    }
+  }
+}
+
+/**
+ * HoloScript+ AST Types
+ */
+export interface HSPlusNode {
+  type: 'directive' | 'trait' | 'lifecycle' | 'state' | 'for' | 'if' | 'import' | 'component' | 'element' | 'fragment' | 'Program';
+  [key: string]: any;
+}
+
+export interface HSPlusAST extends HSPlusNode {
+  type: 'Program';
+  body: HSPlusNode[];
+  version: string;
+  root: HSPlusNode;
+  imports: Array<{ path: string; alias: string }>;
+  hasState: boolean;
+  hasVRTraits: boolean;
+  hasControlFlow: boolean;
+}
+
+export interface HSPlusDirective extends HSPlusNode {
+  type: 'directive' | 'trait' | 'lifecycle' | 'state' | 'for' | 'if' | 'import' | 'fragment';
+  name: string;
+  args: string[];
+  enableTypeScriptImports?: boolean;
+  enableVRTraits?: boolean;
+}
+
+export interface HSPlusCompileResult {
+  success: boolean;
+  code?: string;
+  sourceMap?: any;
+  errors: Array<{ message: string; line: number; column: number }>;
+  ast?: any;
+  compiledExpressions?: any;
+  requiredCompanions?: string[];
+  features?: any;
+  warnings?: any[];
+  [key: string]: any;
+}
+
+export interface HSPlusParserOptions {
+  sourceMap?: boolean;
+  strict?: boolean;
+  enableTypeScriptImports?: boolean;
+  enableVRTraits?: boolean;
+}
+
+export type VRTraitName =
+  | 'grabbable'
+  | 'throwable'
+  | 'pointable'
+  | 'scalable'
+  | 'draggable'
+  | 'rotatable'
+  | 'clickable'
+  | 'hoverable'
+  | 'pressable'
+  | 'stackable'
+  | 'snappable'
+  | 'breakable';
+
+export interface StateDeclaration {
+  name: string;
+  type: HoloScriptType;
+  initialValue?: any;
+  [key: string]: any;
+}
+
+export interface LifecycleHook {
+  name: 'mounted' | 'updated' | 'destroyed';
+  handler: string;
+}
+
+export interface VRLifecycleHook {
+  name: 'grabbed' | 'released' | 'pointed' | 'unpointed' | 'thrown';
+  handler: string;
+}
+
+export interface ControllerHook {
+  name: 'trigger' | 'grip' | 'thumbstick' | 'button_a' | 'button_b';
+  handler: string;
+}
+
+/**
+ * Vector3 type for 3D coordinates
+ */
+export interface Vector3 {
+  x: number;
+  y: number;
+  z: number;
+}
+
+/**
+ * Color type for RGBA colors
+ */
+export interface Color {
+  r: number;
+  g: number;
+  b: number;
+  a?: number;
+}
+
+/**
+ * VR Hand representation
+ */
+export interface VRHand {
+  position: Vector3;
+  rotation: Vector3;
+  pinch: number;
+  grip: number;
+  pointing: boolean;
+}
+
+/**
+ * HoloScript+ Runtime built-in functions
+ */
+export interface HSPlusBuiltins {
+  log: (...args: any[]) => void;
+  warn: (...args: any[]) => void;
+  error: (...args: any[]) => void;
+  setTimeout: (fn: () => void, ms: number) => number;
+  clearTimeout: (id: number) => void;
+  setInterval: (fn: () => void, ms: number) => number;
+  clearInterval: (id: number) => void;
+  fetch: (url: string, options?: any) => Promise<any>;
+  emit: (event: string, data?: any) => void;
+  on: (event: string, handler: (data: any) => void) => void;
+  off: (event: string, handler?: (data: any) => void) => void;
+  [key: string]: any;
+}
+
+/**
+ * HoloScript+ Runtime interface
+ */
+export interface HSPlusRuntime {
+  state: Record<string, any>;
+  props: Record<string, any>;
+  refs: Record<string, any>;
+  builtins: HSPlusBuiltins;
+  execute: (ast: HSPlusAST) => any;
+  evaluate: (expression: string) => any;
+  callMethod: (name: string, args: any[]) => any;
+  setState: (key: string, value: any) => void;
+  getState: (key: string) => any;
+  destroy: () => void;
+}