@holoscript/core 6.0.3 → 7.0.0

package/dist/chunk-ZGTGVSTZ.js

@@ -1,422 +0,0 @@
-// src/compiler/SemanticSceneGraph.ts
-var DEFAULT_CONTEXT = {
-  "@vocab": "https://holoscript.dev/schema/",
-  schema: "https://schema.org/",
-  hs: "https://holoscript.dev/schema/",
-  xsd: "http://www.w3.org/2001/XMLSchema#",
-  rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-};
-function generateSemanticSceneGraph(composition, options = {}) {
-  const generator = new SceneGraphGenerator(options);
-  const graph = generator.convert(composition);
-  return JSON.stringify(graph, null, options.pretty !== false ? 2 : void 0);
-}
-function generateSemanticSceneGraphObject(composition, options = {}) {
-  const generator = new SceneGraphGenerator(options);
-  return generator.convert(composition);
-}
-var SceneGraphGenerator = class {
-  constructor(options = {}) {
-    this.idCounter = 0;
-    this.baseURI = options.baseURI ?? "urn:holoscript:";
-    this.includeSourceLocations = options.includeSourceLocations ?? false;
-    this.includeMetadata = options.includeMetadata ?? true;
-    this.maxDepth = options.maxDepth ?? 10;
-    this.contextExtensions = options.contextExtensions ?? {};
-  }
-  /**
-   * Convert a HoloComposition into a JSON-LD scene graph.
-   */
-  convert(composition) {
-    this.idCounter = 0;
-    const context = {
-      ...DEFAULT_CONTEXT,
-      ...this.contextExtensions
-    };
-    const graph = {
-      "@context": context,
-      "@type": "hs:Composition",
-      "@id": this.makeId(composition.name),
-      "schema:name": composition.name
-    };
-    if (composition.objects?.length > 0) {
-      graph["hs:objects"] = composition.objects.map((obj) => this.convertObject(obj));
-    }
-    if (composition.spatialGroups?.length > 0) {
-      graph["hs:spatialGroups"] = composition.spatialGroups.map(
-        (g) => this.convertSpatialGroup(g, 0)
-      );
-    }
-    if (composition.lights?.length > 0) {
-      graph["hs:lights"] = composition.lights.map((l) => this.convertLight(l));
-    }
-    if (composition.camera) {
-      graph["hs:camera"] = this.convertCamera(composition.camera);
-    }
-    if (composition.timelines?.length > 0) {
-      graph["hs:timelines"] = composition.timelines.map((t) => this.convertTimeline(t));
-    }
-    if (composition.audio?.length > 0) {
-      graph["hs:audio"] = composition.audio.map((a) => this.convertAudio(a));
-    }
-    if (composition.zones?.length > 0) {
-      graph["hs:zones"] = composition.zones.map((z) => this.convertZone(z));
-    }
-    if (composition.npcs?.length > 0) {
-      graph["hs:npcs"] = composition.npcs.map((n) => this.convertNPC(n));
-    }
-    if ((composition.domainBlocks?.length ?? 0) > 0) {
-      graph["hs:domainBlocks"] = composition.domainBlocks.map((d) => this.convertDomainBlock(d));
-    }
-    if (composition.shapes?.length > 0) {
-      graph["hs:shapes"] = composition.shapes.map((s) => this.convertShape(s));
-    }
-    if (this.includeMetadata && composition.environment) {
-      const envProps = {};
-      for (const prop of composition.environment.properties) {
-        envProps[prop.key] = this.serializeValue(prop.value);
-      }
-      graph["hs:environment"] = {
-        "@type": "hs:Environment",
-        ...envProps
-      };
-    }
-    if (this.includeMetadata && composition.state) {
-      const stateProps = {};
-      for (const prop of composition.state.properties) {
-        stateProps[prop.key] = this.serializeValue(prop.value);
-      }
-      graph["hs:state"] = {
-        "@type": "hs:State",
-        ...stateProps
-      };
-    }
-    return graph;
-  }
-  // ---------------------------------------------------------------------------
-  // Object conversion
-  // ---------------------------------------------------------------------------
-  convertObject(obj) {
-    const node = {
-      "@type": "hs:Object",
-      "@id": this.makeId(obj.name),
-      "schema:name": obj.name
-    };
-    if (obj.template) {
-      node["hs:template"] = obj.template;
-    }
-    if (obj.properties?.length > 0) {
-      const props = {};
-      for (const prop of obj.properties) {
-        props[prop.key] = this.serializeValue(prop.value);
-      }
-      node["hs:properties"] = props;
-    }
-    if (obj.traits?.length > 0) {
-      node["hs:traits"] = obj.traits.map((t) => this.convertTrait(t));
-    }
-    if (obj.children?.length) {
-      node["hs:children"] = obj.children.map((c) => this.convertObject(c));
-    }
-    if (obj.platformConstraint) {
-      node["hs:platformConstraint"] = {
-        include: obj.platformConstraint.include,
-        exclude: obj.platformConstraint.exclude
-      };
-    }
-    if (this.includeSourceLocations && obj.loc) {
-      node["hs:sourceLocation"] = {
-        startLine: obj.loc.start.line,
-        startColumn: obj.loc.start.column,
-        endLine: obj.loc.end.line,
-        endColumn: obj.loc.end.column
-      };
-    }
-    return node;
-  }
-  // ---------------------------------------------------------------------------
-  // Trait conversion
-  // ---------------------------------------------------------------------------
-  convertTrait(trait) {
-    const node = {
-      "@type": "hs:Trait",
-      "schema:name": trait.name
-    };
-    if (trait.config && Object.keys(trait.config).length > 0) {
-      const config = {};
-      for (const [key, val] of Object.entries(trait.config)) {
-        config[key] = this.serializeValue(val);
-      }
-      node["hs:config"] = config;
-    }
-    return node;
-  }
-  // ---------------------------------------------------------------------------
-  // Spatial group conversion
-  // ---------------------------------------------------------------------------
-  convertSpatialGroup(group, depth) {
-    const node = {
-      "@type": "hs:SpatialGroup",
-      "@id": this.makeId(group.name),
-      "schema:name": group.name
-    };
-    if (group.properties?.length > 0) {
-      const props = {};
-      for (const prop of group.properties) {
-        props[prop.key] = this.serializeValue(prop.value);
-      }
-      node["hs:properties"] = props;
-    }
-    if (group.objects?.length > 0) {
-      node["hs:objects"] = group.objects.map((o) => this.convertObject(o));
-    }
-    if (group.groups?.length && depth < this.maxDepth) {
-      node["hs:children"] = group.groups.map((g) => this.convertSpatialGroup(g, depth + 1));
-    }
-    if (group.platformConstraint) {
-      node["hs:platformConstraint"] = {
-        include: group.platformConstraint.include,
-        exclude: group.platformConstraint.exclude
-      };
-    }
-    return node;
-  }
-  // ---------------------------------------------------------------------------
-  // Light conversion
-  // ---------------------------------------------------------------------------
-  convertLight(light) {
-    const node = {
-      "@type": "hs:Light",
-      "@id": this.makeId(light.name),
-      "schema:name": light.name,
-      "hs:lightType": light.lightType
-    };
-    if (light.properties?.length > 0) {
-      const props = {};
-      for (const prop of light.properties) {
-        props[prop.key] = this.serializeValue(prop.value);
-      }
-      node["hs:properties"] = props;
-    }
-    return node;
-  }
-  // ---------------------------------------------------------------------------
-  // Camera conversion
-  // ---------------------------------------------------------------------------
-  convertCamera(camera) {
-    const node = {
-      "@type": "hs:Camera",
-      "hs:cameraType": camera.cameraType
-    };
-    if (camera.properties?.length > 0) {
-      const props = {};
-      for (const prop of camera.properties) {
-        props[prop.key] = this.serializeValue(prop.value);
-      }
-      node["hs:properties"] = props;
-    }
-    return node;
-  }
-  // ---------------------------------------------------------------------------
-  // Timeline conversion
-  // ---------------------------------------------------------------------------
-  convertTimeline(timeline) {
-    const node = {
-      "@type": "hs:Timeline",
-      "@id": this.makeId(timeline.name),
-      "schema:name": timeline.name
-    };
-    if (timeline.autoplay !== void 0) {
-      node["hs:autoplay"] = timeline.autoplay;
-    }
-    if (timeline.loop !== void 0) {
-      node["hs:loop"] = timeline.loop;
-    }
-    if (timeline.entries?.length > 0) {
-      node["hs:entries"] = timeline.entries.map((e) => this.convertTimelineEntry(e));
-    }
-    return node;
-  }
-  convertTimelineEntry(entry) {
-    const node = {
-      "@type": "hs:TimelineEntry",
-      "hs:time": entry.time,
-      "hs:actionKind": entry.action.kind
-    };
-    if (entry.action.kind === "animate") {
-      node["hs:target"] = entry.action.target;
-      node["hs:animateProperties"] = entry.action.properties;
-    } else if (entry.action.kind === "emit") {
-      node["hs:event"] = entry.action.event;
-      if (entry.action.data !== void 0) {
-        node["hs:data"] = entry.action.data;
-      }
-    } else if (entry.action.kind === "call") {
-      node["hs:method"] = entry.action.method;
-      if (entry.action.args) {
-        node["hs:args"] = entry.action.args;
-      }
-    }
-    return node;
-  }
-  // ---------------------------------------------------------------------------
-  // Audio conversion
-  // ---------------------------------------------------------------------------
-  convertAudio(audio) {
-    const node = {
-      "@type": "hs:Audio",
-      "@id": this.makeId(audio.name),
-      "schema:name": audio.name
-    };
-    if (audio.properties?.length > 0) {
-      const props = {};
-      for (const prop of audio.properties) {
-        props[prop.key] = this.serializeValue(prop.value);
-      }
-      node["hs:properties"] = props;
-    }
-    return node;
-  }
-  // ---------------------------------------------------------------------------
-  // Zone conversion
-  // ---------------------------------------------------------------------------
-  convertZone(zone) {
-    const node = {
-      "@type": "hs:Zone",
-      "@id": this.makeId(zone.name),
-      "schema:name": zone.name
-    };
-    if (zone.properties?.length > 0) {
-      const props = {};
-      for (const prop of zone.properties) {
-        props[prop.key] = this.serializeValue(prop.value);
-      }
-      node["hs:properties"] = props;
-    }
-    if (zone.handlers?.length > 0) {
-      node["hs:handlers"] = zone.handlers.map((h) => ({
-        "@type": "hs:EventHandler",
-        "hs:event": h.event
-      }));
-    }
-    return node;
-  }
-  // ---------------------------------------------------------------------------
-  // NPC conversion
-  // ---------------------------------------------------------------------------
-  convertNPC(npc) {
-    const node = {
-      "@type": "hs:NPC",
-      "@id": this.makeId(npc.name),
-      "schema:name": npc.name
-    };
-    if (npc.npcType) node["hs:npcType"] = npc.npcType;
-    if (npc.model) node["hs:model"] = npc.model;
-    if (npc.dialogueTree) node["hs:dialogueTree"] = npc.dialogueTree;
-    if (npc.properties?.length > 0) {
-      const props = {};
-      for (const prop of npc.properties) {
-        props[prop.key] = this.serializeValue(prop.value);
-      }
-      node["hs:properties"] = props;
-    }
-    if (npc.behaviors?.length > 0) {
-      node["hs:behaviors"] = npc.behaviors.map((b) => ({
-        "@type": "hs:Behavior",
-        "schema:name": b.name,
-        "hs:trigger": b.trigger,
-        "hs:priority": b.priority
-      }));
-    }
-    return node;
-  }
-  // ---------------------------------------------------------------------------
-  // Domain block conversion
-  // ---------------------------------------------------------------------------
-  convertDomainBlock(block) {
-    const node = {
-      "@type": `hs:DomainBlock`,
-      "@id": this.makeId(block.name),
-      "schema:name": block.name,
-      "hs:domain": block.domain,
-      "hs:keyword": block.keyword
-    };
-    if (block.traits?.length > 0) {
-      node["hs:traits"] = block.traits;
-    }
-    if (block.properties && Object.keys(block.properties).length > 0) {
-      const props = {};
-      for (const [key, val] of Object.entries(block.properties)) {
-        props[key] = this.serializeValue(val);
-      }
-      node["hs:properties"] = props;
-    }
-    if (block.children?.length) {
-      node["hs:children"] = block.children.map((c) => this.convertObject(c));
-    }
-    return node;
-  }
-  // ---------------------------------------------------------------------------
-  // Shape conversion
-  // ---------------------------------------------------------------------------
-  convertShape(shape) {
-    const node = {
-      "@type": "hs:Shape",
-      "@id": this.makeId(shape.name),
-      "schema:name": shape.name,
-      "hs:shapeType": shape.shapeType
-    };
-    if (shape.properties?.length > 0) {
-      const props = {};
-      for (const prop of shape.properties) {
-        props[prop.key] = this.serializeValue(prop.value);
-      }
-      node["hs:properties"] = props;
-    }
-    return node;
-  }
-  // ---------------------------------------------------------------------------
-  // Utility helpers
-  // ---------------------------------------------------------------------------
-  makeId(name) {
-    const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-    return `${this.baseURI}${slug}-${this.idCounter++}`;
-  }
-  serializeValue(value) {
-    if (value === null || value === void 0) return null;
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      return value;
-    }
-    if (Array.isArray(value)) {
-      return value.map((v) => this.serializeValue(v));
-    }
-    if (typeof value === "object" && "__bind" in value) {
-      return {
-        "@type": "hs:Binding",
-        "hs:source": value.source,
-        "hs:transform": value.transform
-      };
-    }
-    if (typeof value === "object") {
-      const result = {};
-      for (const [k, v] of Object.entries(value)) {
-        result[k] = this.serializeValue(v);
-      }
-      return result;
-    }
-    return value;
-  }
-};
-var SemanticSceneGraph = class {
-  static generate(composition, options) {
-    return generateSemanticSceneGraph(composition, options);
-  }
-  static generateObject(composition, options) {
-    return generateSemanticSceneGraphObject(composition, options);
-  }
-};
-var SemanticSceneGraph_default = SemanticSceneGraph;
-
-export { SceneGraphGenerator, SemanticSceneGraph, SemanticSceneGraph_default, generateSemanticSceneGraph, generateSemanticSceneGraphObject };
-//# sourceMappingURL=chunk-ZGTGVSTZ.js.map
-//# sourceMappingURL=chunk-ZGTGVSTZ.js.map