@holoscript/core 6.0.3 → 7.0.0

package/dist/chunk-EGIZHYJP.cjs

@@ -1,85 +0,0 @@
-'use strict';
-
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var __privateWrapper = (obj, member, setter, getter) => ({
-  set _(value) {
-    __privateSet(obj, member, value, setter);
-  },
-  get _() {
-    return __privateGet(obj, member, getter);
-  }
-});
-
-exports.__commonJS = __commonJS;
-exports.__decorateClass = __decorateClass;
-exports.__esm = __esm;
-exports.__export = __export;
-exports.__privateAdd = __privateAdd;
-exports.__privateGet = __privateGet;
-exports.__privateMethod = __privateMethod;
-exports.__privateSet = __privateSet;
-exports.__privateWrapper = __privateWrapper;
-exports.__publicField = __publicField;
-exports.__reExport = __reExport;
-exports.__require = __require;
-exports.__toCommonJS = __toCommonJS;
-exports.__toESM = __toESM;
-//# sourceMappingURL=chunk-EGIZHYJP.cjs.map
-//# sourceMappingURL=chunk-EGIZHYJP.cjs.map

package/dist/chunk-EJA7G2C4.cjs

@@ -1,428 +0,0 @@
-'use strict';
-
-// 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;
-
-exports.SceneGraphGenerator = SceneGraphGenerator;
-exports.SemanticSceneGraph = SemanticSceneGraph;
-exports.SemanticSceneGraph_default = SemanticSceneGraph_default;
-exports.generateSemanticSceneGraph = generateSemanticSceneGraph;
-exports.generateSemanticSceneGraphObject = generateSemanticSceneGraphObject;
-//# sourceMappingURL=chunk-EJA7G2C4.cjs.map
-//# sourceMappingURL=chunk-EJA7G2C4.cjs.map