@holoscript/core 6.0.4 → 7.0.0

package/dist/HoloScriptPlusParser-NC5FE6AL.cjs

@@ -1,697 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var chunkQ4QX3AET_cjs = require('./chunk-Q4QX3AET.cjs');
-var chunkT7LEXZUZ_cjs = require('./chunk-T7LEXZUZ.cjs');
-require('./chunk-ILRBGFVD.cjs');
-require('./chunk-3SAK5KFL.cjs');
-
-// src/HoloScriptPlusParser.ts
-var HoloScriptPlusParser = class {
-  constructor() {
-    this.baseParser = new chunkT7LEXZUZ_cjs.HoloScriptCodeParser();
-  }
-  /**
-   * Parse HoloScript+ code with trait annotations
-   */
-  parse(code) {
-    const baseResult = this.baseParser.parse(code);
-    const ast = baseResult.ast;
-    return this.enhanceWithTraits(ast, code);
-  }
-  /**
-   * Enhance AST nodes with trait annotations
-   */
-  enhanceWithTraits(ast, code) {
-    return ast.map((node) => {
-      if (node.type === "orb") {
-        return this.enhanceOrbNodeWithTraits(node, code);
-      }
-      return node;
-    });
-  }
-  /**
-   * Enhance OrbNode with trait annotations
-   */
-  enhanceOrbNodeWithTraits(node, code) {
-    const orbNode = node;
-    const enhanced = {
-      ...orbNode,
-      traits: [],
-      graphics: {}
-    };
-    const traits = this.extractTraitAnnotations(code, node.line);
-    enhanced.traits = traits;
-    if (traits.length > 0) {
-      enhanced.graphics = this.buildGraphicsConfig(traits);
-    }
-    return enhanced;
-  }
-  /**
-   * Extract trait annotations from code
-   */
-  extractTraitAnnotations(code, _orbLine) {
-    const traits = [];
-    const traitRegex = /@(material|lighting|rendering|shader|networked|rpc|joint|ik)\s*\{((?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*)\}/g;
-    let match;
-    while ((match = traitRegex.exec(code)) !== null) {
-      const type = match[1];
-      const configStr = match[2];
-      try {
-        const config = this.parseTraitConfig(configStr, type);
-        switch (type) {
-          case "material":
-            traits.push({
-              type: "material",
-              config
-            });
-            break;
-          case "lighting":
-            traits.push({
-              type: "lighting",
-              config
-            });
-            break;
-          case "rendering":
-            traits.push({
-              type: "rendering",
-              config
-            });
-            break;
-          case "shader":
-            traits.push({
-              type: "shader",
-              config
-            });
-            break;
-          case "networked":
-            traits.push({
-              type: "networked",
-              config
-            });
-            break;
-          case "rpc":
-            traits.push({
-              type: "rpc",
-              config
-            });
-            break;
-          case "joint":
-            traits.push({
-              type: "joint",
-              config
-            });
-            break;
-          case "ik":
-            traits.push({
-              type: "ik",
-              config
-            });
-            break;
-        }
-      } catch (e) {
-        console.warn(`Failed to parse ${type} trait annotation:`, e);
-      }
-    }
-    return traits;
-  }
-  /**
-   * Parse trait configuration with support for inline code (backticks)
-   */
-  parseTraitConfig(str, traitType) {
-    if (traitType === "shader") {
-      return this.parseShaderConfig(str);
-    }
-    return this.parseObjectLiteral(str);
-  }
-  /**
-   * Parse shader configuration with inline GLSL support
-   */
-  parseShaderConfig(str) {
-    const config = {};
-    const backtickStrings = [];
-    const processedStr = str.replace(/`([^`]*)`/g, (_, content) => {
-      backtickStrings.push(content);
-      return `__BACKTICK_${backtickStrings.length - 1}__`;
-    });
-    const parsed = this.parseObjectLiteral(processedStr);
-    for (const [key, value] of Object.entries(parsed)) {
-      if (typeof value === "string" && value.startsWith("__BACKTICK_")) {
-        const index = parseInt(value.replace("__BACKTICK_", "").replace("__", ""));
-        config[key] = backtickStrings[index];
-      } else {
-        config[key] = value;
-      }
-    }
-    return config;
-  }
-  /**
-   * Parse object literal from string
-   * Supports nested objects and arrays
-   */
-  parseObjectLiteral(str) {
-    const config = {};
-    let depth = 0;
-    let current = "";
-    const pairs = [];
-    for (let i = 0; i < str.length; i++) {
-      const char = str[i];
-      if (char === "{" || char === "[") {
-        depth++;
-      } else if (char === "}" || char === "]") {
-        depth--;
-      } else if (char === "," && depth === 0) {
-        pairs.push(current.trim());
-        current = "";
-        continue;
-      }
-      current += char;
-    }
-    if (current.trim()) {
-      pairs.push(current.trim());
-    }
-    for (const pair of pairs) {
-      const colonIndex = pair.indexOf(":");
-      if (colonIndex === -1) continue;
-      const key = pair.substring(0, colonIndex).trim();
-      const value = pair.substring(colonIndex + 1).trim();
-      config[key] = this.parseValue(value);
-    }
-    return config;
-  }
-  /**
-   * Parse individual values
-   */
-  parseValue(str) {
-    str = str.trim();
-    if (str === "true") return true;
-    if (str === "false") return false;
-    if (/^-?\d+(\.\d+)?$/.test(str)) return parseFloat(str);
-    if (str.startsWith('"') && str.endsWith('"') || str.startsWith("'") && str.endsWith("'")) {
-      return str.slice(1, -1);
-    }
-    if (str.startsWith("{") && str.endsWith("}")) {
-      return this.parseObjectLiteral(str.slice(1, -1));
-    }
-    if (str.startsWith("[") && str.endsWith("]")) {
-      const items = str.slice(1, -1).split(",");
-      return items.map((item) => this.parseValue(item));
-    }
-    return str;
-  }
-  /**
-   * Build GraphicsConfiguration from trait annotations
-   */
-  buildGraphicsConfig(traits) {
-    const config = {};
-    for (const trait of traits) {
-      switch (trait.type) {
-        case "material":
-          config.material = trait.config;
-          break;
-        case "lighting":
-          config.lighting = trait.config;
-          break;
-        case "rendering":
-          config.rendering = trait.config;
-          break;
-        case "shader":
-          config.shader = trait.config;
-          break;
-        case "networked":
-          config.networked = trait.config;
-          break;
-        case "rpc":
-          config.rpc = trait.config;
-          break;
-        case "joint":
-          config.joint = trait.config;
-          break;
-        case "ik":
-          config.ik = trait.config;
-          break;
-      }
-    }
-    return config;
-  }
-  /**
-   * Validate trait annotation configuration
-   */
-  validateTraitAnnotation(trait) {
-    const errors = [];
-    switch (trait.type) {
-      case "material":
-        errors.push(...this.validateMaterialTrait(trait));
-        break;
-      case "lighting":
-        errors.push(...this.validateLightingTrait(trait));
-        break;
-      case "rendering":
-        errors.push(...this.validateRenderingTrait(trait));
-        break;
-      case "shader":
-        errors.push(...this.validateShaderTrait(trait));
-        break;
-      case "networked":
-        errors.push(...this.validateNetworkedTrait(trait));
-        break;
-      case "joint":
-        errors.push(...this.validateJointTrait(trait));
-        break;
-      case "ik":
-        errors.push(...this.validateIKTrait(trait));
-        break;
-    }
-    return {
-      valid: errors.length === 0,
-      errors
-    };
-  }
-  /**
-   * Validate material trait configuration
-   */
-  validateMaterialTrait(trait) {
-    const errors = [];
-    const { config } = trait;
-    if (config.pbr) {
-      if (config.pbr.metallic !== void 0 && (config.pbr.metallic < 0 || config.pbr.metallic > 1)) {
-        errors.push("material.pbr.metallic must be between 0 and 1");
-      }
-      if (config.pbr.roughness !== void 0 && (config.pbr.roughness < 0 || config.pbr.roughness > 1)) {
-        errors.push("material.pbr.roughness must be between 0 and 1");
-      }
-    }
-    if (config.compression && !["none", "dxt", "astc", "basis"].includes(config.compression)) {
-      errors.push(`material.compression must be one of: none, dxt, astc, basis`);
-    }
-    return errors;
-  }
-  /**
-   * Validate lighting trait configuration
-   */
-  validateLightingTrait(trait) {
-    const errors = [];
-    const { config } = trait;
-    if (config.preset && !["studio", "outdoor", "interior", "night", "sunset"].includes(config.preset)) {
-      errors.push("lighting.preset must be one of: studio, outdoor, interior, night, sunset");
-    }
-    if (config.lights) {
-      config.lights.forEach((light, index) => {
-        if (!["directional", "point", "spot", "area", "ambient"].includes(light.type)) {
-          errors.push(`lighting.lights[${index}].type must be a valid light type`);
-        }
-        if (light.intensity !== void 0 && light.intensity < 0) {
-          errors.push(`lighting.lights[${index}].intensity must be >= 0`);
-        }
-      });
-    }
-    return errors;
-  }
-  /**
-   * Validate rendering trait configuration
-   */
-  validateRenderingTrait(trait) {
-    const errors = [];
-    const { config } = trait;
-    if (config.quality && !["low", "medium", "high", "ultra"].includes(config.quality)) {
-      errors.push("rendering.quality must be one of: low, medium, high, ultra");
-    }
-    if (config.platform && !["mobile", "vr", "desktop"].includes(config.platform)) {
-      errors.push("rendering.platform must be one of: mobile, vr, desktop");
-    }
-    if (config.compression && !["none", "dxt", "astc", "basis"].includes(config.compression)) {
-      errors.push("rendering.compression must be one of: none, dxt, astc, basis");
-    }
-    if (config.maxTextureResolution && config.maxTextureResolution < 128) {
-      errors.push("rendering.maxTextureResolution must be >= 128");
-    }
-    if (config.targetFPS && (config.targetFPS < 24 || config.targetFPS > 240)) {
-      errors.push("rendering.targetFPS must be between 24 and 240");
-    }
-    return errors;
-  }
-  /**
-   * Get trait annotations as graphics traits
-   */
-  createGraphicsTraits(config) {
-    return {
-      material: config.material ? this.createMaterialTrait(config.material) : null,
-      lighting: config.lighting ? this.createLightingTrait(config.lighting) : null,
-      rendering: config.rendering ? this.createRenderingTrait(config.rendering) : null,
-      shader: config.shader ? this.createShaderTrait(config.shader) : null
-    };
-  }
-  /**
-   * Create MaterialTrait from config
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- dynamic material config from parsed AST
-  createMaterialTrait(config) {
-    const material = new chunkQ4QX3AET_cjs.MaterialTrait({
-      type: config.type || "pbr",
-      pbr: config.pbr
-    });
-    if (config.compression) {
-      material.setCompression(config.compression);
-    }
-    if (config.instancing) {
-      material.setInstanced(true);
-    }
-    if (config.streaming) {
-      material.setTextureStreaming(true);
-    }
-    if (config.textures) {
-      config.textures.forEach((tex) => {
-        material.addTexture(tex);
-      });
-    }
-    return material;
-  }
-  /**
-   * Create LightingTrait from config
-   */
-  createLightingTrait(config) {
-    let lighting;
-    if (config.preset) {
-      const presetFactory = chunkQ4QX3AET_cjs.LIGHTING_PRESETS[config.preset];
-      const presetConfig = presetFactory ? presetFactory() : void 0;
-      lighting = new chunkQ4QX3AET_cjs.LightingTrait(presetConfig);
-    } else {
-      lighting = new chunkQ4QX3AET_cjs.LightingTrait();
-    }
-    if (config.globalIllumination) {
-      lighting.setGlobalIllumination(config.globalIllumination);
-    }
-    if (config.lights) {
-      config.lights.forEach((light) => {
-        lighting.addLight(light);
-      });
-    }
-    return lighting;
-  }
-  /**
-   * Create RenderingTrait from config
-   */
-  createRenderingTrait(config) {
-    const rendering = new chunkQ4QX3AET_cjs.RenderingTrait();
-    if (config.quality) {
-      rendering.applyQualityPreset(config.quality);
-    }
-    if (config.platform) {
-      switch (config.platform) {
-        case "mobile":
-          rendering.optimizeForMobile();
-          break;
-        case "vr":
-          rendering.optimizeForVRAR(config.targetFPS || 90);
-          break;
-        case "desktop":
-          rendering.optimizeForDesktop();
-          break;
-      }
-    }
-    if (config.lod !== false) {
-      rendering.setupLODLevels("automatic");
-    }
-    if (config.culling !== false) {
-      rendering.setFrustumCulling(true);
-    }
-    if (config.compression) {
-      rendering.setTextureCompression(config.compression);
-    }
-    if (config.maxTextureResolution) {
-      rendering.setMaxTextureResolution(config.maxTextureResolution);
-    }
-    return rendering;
-  }
-  /**
-   * Create ShaderTrait from config
-   */
-  createShaderTrait(config) {
-    if (config.preset && chunkQ4QX3AET_cjs.SHADER_PRESETS[config.preset]) {
-      const preset = chunkQ4QX3AET_cjs.SHADER_PRESETS[config.preset];
-      return new chunkQ4QX3AET_cjs.ShaderTrait(preset);
-    }
-    const shaderConfig = {
-      source: {
-        language: config.language || "glsl",
-        vertex: config.vertex,
-        fragment: config.fragment
-      },
-      uniforms: config.uniforms,
-      includes: config.includes?.map((path) => ({ path })),
-      blendMode: config.blendMode,
-      depthTest: config.depthTest,
-      depthWrite: config.depthWrite,
-      cullFace: config.cullFace
-    };
-    return new chunkQ4QX3AET_cjs.ShaderTrait(shaderConfig);
-  }
-  /**
-   * Validate shader trait configuration
-   */
-  validateShaderTrait(trait) {
-    const errors = [];
-    const { config } = trait;
-    if (!config.preset && !config.vertex && !config.fragment) {
-      errors.push("shader must have either preset or vertex/fragment code");
-    }
-    if (config.preset && !chunkQ4QX3AET_cjs.SHADER_PRESETS[config.preset]) {
-      errors.push(
-        `shader.preset "${config.preset}" is not a valid preset. Available: hologram, forceField, dissolve`
-      );
-    }
-    if (config.language && !["glsl", "hlsl", "wgsl"].includes(config.language)) {
-      errors.push("shader.language must be one of: glsl, hlsl, wgsl");
-    }
-    if (config.blendMode && !["opaque", "blend", "additive", "multiply"].includes(config.blendMode)) {
-      errors.push("shader.blendMode must be one of: opaque, blend, additive, multiply");
-    }
-    if (config.cullFace && !["none", "front", "back"].includes(config.cullFace)) {
-      errors.push("shader.cullFace must be one of: none, front, back");
-    }
-    return errors;
-  }
-  /**
-   * Validate networked trait configuration
-   */
-  validateNetworkedTrait(trait) {
-    const errors = [];
-    const { config } = trait;
-    if (config.mode && !["owner", "shared", "server"].includes(config.mode)) {
-      errors.push("networked.mode must be one of: owner, shared, server");
-    }
-    if (config.syncRate !== void 0 && (config.syncRate < 1 || config.syncRate > 60)) {
-      errors.push("networked.syncRate must be between 1 and 60 Hz");
-    }
-    return errors;
-  }
-  /**
-   * Validate joint trait configuration
-   */
-  validateJointTrait(trait) {
-    const errors = [];
-    const { config } = trait;
-    if (!config.jointType) {
-      errors.push("joint.jointType is required");
-    } else if (!["fixed", "hinge", "ball", "slider", "spring"].includes(config.jointType)) {
-      errors.push("joint.jointType must be one of: fixed, hinge, ball, slider, spring");
-    }
-    if (config.breakForce !== void 0 && config.breakForce < 0) {
-      errors.push("joint.breakForce must be >= 0");
-    }
-    return errors;
-  }
-  /**
-   * Validate IK trait configuration
-   */
-  validateIKTrait(trait) {
-    const errors = [];
-    const { config } = trait;
-    if (!config.chain) {
-      errors.push("ik.chain is required");
-    }
-    if (config.chainLength !== void 0 && config.chainLength < 1) {
-      errors.push("ik.chainLength must be >= 1");
-    }
-    if (config.iterations !== void 0 && config.iterations < 1) {
-      errors.push("ik.iterations must be >= 1");
-    }
-    if (config.weight !== void 0 && (config.weight < 0 || config.weight > 1)) {
-      errors.push("ik.weight must be between 0 and 1");
-    }
-    return errors;
-  }
-  // ==========================================================================
-  // Module System — @import / @export
-  // ==========================================================================
-  /**
-   * Parse HoloScript+ code and also extract module-level @import / @export
-   * declarations from the source header.
-   *
-   * Returns both the enhanced AST and a structured module header so callers
-   * (e.g. ModuleResolver, SceneRunner) can understand the file's dependencies
-   * without running a separate pass.
-   */
-  parseWithModules(code, fromFile = "<inline>") {
-    const ast = this.parse(code);
-    const { imports, exports: exports$1 } = this.parseModuleHeader(code, fromFile);
-    return { ast, imports, exports: exports$1 };
-  }
-  /**
-   * Scan the top of a source string and return all @import / @export
-   * declarations before the first non-directive, non-comment line.
-   */
-  parseModuleHeader(code, _fromFile = "<inline>") {
-    const imports = [];
-    const exports$1 = [];
-    for (const rawLine of code.split("\n")) {
-      const line = rawLine.trim();
-      if (!line || line.startsWith("//") || line.startsWith("#")) continue;
-      const imp = this.parseImportDirective(line);
-      if (imp) {
-        imports.push(imp);
-        continue;
-      }
-      const exp = this.parseExportDirective(line);
-      if (exp) {
-        exports$1.push(...exp);
-        continue;
-      }
-      break;
-    }
-    return { imports, exports: exports$1 };
-  }
-  /**
-   * Parse a single @import directive line.
-   *
-   * Accepted forms:
-   *   @import @physics, @ai_npc from "./physics.hs"
-   *   @import * from "./shared.hs"
-   *   @import @physics as @p from "./physics.hs"
-   *
-   * Returns null if the line is not an @import.
-   */
-  parseImportDirective(line) {
-    const m = line.match(/^@import\s+([\w@*,\s]+?)(?:\s+as\s+(@\w+))?\s+from\s+["']([^"']+)["']/);
-    if (!m) return null;
-    const specifiersPart = m[1].trim();
-    const alias = m[2]?.replace("@", "");
-    const source = m[3];
-    const specifiers = specifiersPart === "*" ? ["*"] : specifiersPart.split(",").map((s) => s.trim().replace("@", "")).filter(Boolean);
-    return { specifiers, source, ...alias ? { alias } : {} };
-  }
-  /**
-   * Parse a single @export directive line.
-   *
-   *   @export @turret, @enemy
-   *
-   * Returns null if the line is not an @export.
-   */
-  parseExportDirective(line) {
-    const m = line.match(/^@export\s+([\w@,\s]+)/);
-    if (!m) return null;
-    return m[1].split(",").map((s) => s.trim().replace("@", "")).filter(Boolean);
-  }
-  /**
-   * Parse a single trait composition assignment line.
-   *
-   *   @turret = @physics + @ai_npc + @targeting
-   *
-   * This can appear anywhere in a HoloScript+ file body.
-   * Returns null if the line is not a composition assignment.
-   *
-   * The returned AST node type is `'trait_composition'` and can be
-   * emitted by callers into the broader AST to register composed traits.
-   */
-  parseCompositionDirective(line) {
-    const m = line.trim().match(/^@(\w+)\s*=\s*((?:@\w+\s*\+\s*)*@\w+)/);
-    if (!m) return null;
-    const name = m[1];
-    const sources = m[2].split("+").map((s) => s.trim().replace("@", "")).filter(Boolean);
-    return { type: "trait_composition", name, sources };
-  }
-  /**
-   * Scan an entire source string for trait composition assignments and return
-   * all found definitions in document order.
-   *
-   * @param code  Full HoloScript+ source
-   * @returns     Array of composition definitions ready for TraitBinder registration
-   */
-  parseCompositionBlock(code) {
-    const results = [];
-    for (const rawLine of code.split("\n")) {
-      const node = this.parseCompositionDirective(rawLine.trim());
-      if (node) results.push(node);
-    }
-    return results;
-  }
-  // ==========================================================================
-  // Reactive State — state { } / on event { }  (Sprint 3)
-  // ==========================================================================
-  /**
-   * Parse a `state { ... }` block from HoloScript+ source.
-   *
-   * Accepted syntax:
-   *   state {
-   *     hp = 100
-   *     speed = 5.5
-   *     alive = true
-   *     name = "hero"
-   *   }
-   *
-   * The block may appear inline or multi-line. Values are coerced to their
-   * inferred JS types (number, boolean, string). The returned list is ordered
-   * by declaration order and is suitable for `new ReactiveState(entries)`.
-   *
-   * Returns null if no `state {` opener is found in the source.
-   */
-  parseStateBlock(code) {
-    const m = code.match(/\bstate\s*\{([^}]*)\}/s);
-    if (!m) return null;
-    const body = m[1];
-    const vars = [];
-    for (const rawLine of body.split("\n")) {
-      const line = rawLine.trim();
-      if (!line || line.startsWith("//")) continue;
-      const pair = line.match(/^(\w+)\s*=\s*(.+?)[\s;,]*$/);
-      if (!pair) continue;
-      const [, varName, rawVal] = pair;
-      let value = rawVal.trim();
-      if (rawVal === "true") value = true;
-      else if (rawVal === "false") value = false;
-      else if (!isNaN(Number(rawVal))) value = Number(rawVal);
-      else if (/^["'](.*)["']$/.test(rawVal)) value = rawVal.slice(1, -1);
-      vars.push({ name: varName, value });
-    }
-    return vars;
-  }
-  /**
-   * Parse all `on <event> { ... }` handler blocks from HoloScript+ source.
-   *
-   * Accepted syntax:
-   *   on collide { hp = hp - 10 }
-   *   on death   { alive = false }
-   *
-   * Returns an array of `{ event, body }` records ordered by appearance.
-   * The `body` string is the raw block content suitable for ExpressionEvaluator.
-   * Returns an empty array if no `on` blocks are found.
-   */
-  parseOnBlock(code) {
-    const results = [];
-    const pattern = /\bon\s+(\w+)\s*\{([^}]*)\}/gs;
-    let m;
-    while ((m = pattern.exec(code)) !== null) {
-      const event = m[1];
-      const body = m[2].trim();
-      results.push({ event, body });
-    }
-    return results;
-  }
-};
-var HoloScriptPlusParser_default = HoloScriptPlusParser;
-
-exports.HoloScriptPlusParser = HoloScriptPlusParser;
-exports.default = HoloScriptPlusParser_default;
-//# sourceMappingURL=HoloScriptPlusParser-NC5FE6AL.cjs.map
-//# sourceMappingURL=HoloScriptPlusParser-NC5FE6AL.cjs.map