@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-HYNTS5CP.js

@@ -0,0 +1,422 @@
+// 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-HYNTS5CP.js.map
+//# sourceMappingURL=chunk-HYNTS5CP.js.map