@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-J6M4FPK5.js

@@ -0,0 +1,421 @@
+import { init_CompilerBase, CompilerBase } from './chunk-QPSKHBJP.js';
+import { __export, __esm } from './chunk-OL46QLBJ.js';
+import { ANSCapabilityPath } from '@holoscript/core-types/ans';
+
+// src/compiler/DTDLCompiler.ts
+var DTDLCompiler_exports = {};
+__export(DTDLCompiler_exports, {
+  DTDLCompiler: () => DTDLCompiler,
+  DTDL_TRAIT_COMPONENTS: () => DTDL_TRAIT_COMPONENTS,
+  default: () => DTDLCompiler_default
+});
+var DTDLCompiler, DTDL_TRAIT_COMPONENTS, DTDLCompiler_default;
+var init_DTDLCompiler = __esm({
+  "src/compiler/DTDLCompiler.ts"() {
+    init_CompilerBase();
+    DTDLCompiler = class extends CompilerBase {
+      constructor(options = {}) {
+        super();
+        this.compilerName = "DTDLCompiler";
+        this.generatedInterfaces = [];
+        this.options = {
+          dtdlVersion: options.dtdlVersion ?? 3,
+          namespace: options.namespace || "dtmi:holoscript",
+          modelVersion: options.modelVersion ?? 1,
+          includeDescriptions: options.includeDescriptions ?? true,
+          includeTraitComponents: options.includeTraitComponents ?? true
+        };
+      }
+      getRequiredCapability() {
+        return ANSCapabilityPath.DTDL;
+      }
+      /**
+       * Get trait name from either string or { name: string } format
+       */
+      getTraitName(trait) {
+        return typeof trait === "string" ? trait : trait.name;
+      }
+      /**
+       * Check if traits include a specific trait name
+       */
+      hasTrait(traits, targetTrait) {
+        return traits?.some((t) => this.getTraitName(t) === targetTrait) ?? false;
+      }
+      compile(composition, agentToken, outputPath) {
+        this.validateCompilerAccess(agentToken, outputPath);
+        this.generatedInterfaces = [];
+        if (composition.templates) {
+          for (const template of composition.templates) {
+            this.generatedInterfaces.push(this.compileTemplate(template));
+          }
+        }
+        const mainInterface = this.compileComposition(composition);
+        this.generatedInterfaces.push(mainInterface);
+        if (composition.objects) {
+          for (const obj of composition.objects) {
+            if (this.objectNeedsInterface(obj)) {
+              this.generatedInterfaces.push(this.compileObject(obj));
+            }
+          }
+        }
+        return JSON.stringify(this.generatedInterfaces, null, 2);
+      }
+      compileComposition(composition) {
+        const modelId = this.generateModelId(composition.name);
+        const contents = [];
+        if (composition.environment) {
+          contents.push(...this.compileEnvironmentProperties(composition.environment));
+        }
+        if (composition.state) {
+          contents.push(...this.compileStateProperties(composition.state));
+        }
+        if (composition.logic) {
+          contents.push(...this.compileLogicCommands(composition.logic));
+        }
+        if (composition.objects) {
+          for (const obj of composition.objects) {
+            contents.push(this.createObjectRelationship(obj));
+          }
+        }
+        if (composition.spatialGroups) {
+          for (const group of composition.spatialGroups) {
+            contents.push({
+              "@type": "Relationship",
+              name: this.sanitizeName(group.name),
+              displayName: group.name,
+              description: `Spatial group containing ${group.objects?.length || 0} objects`
+            });
+          }
+        }
+        const iface = {
+          "@context": this.getDtdlContext(),
+          "@type": "Interface",
+          "@id": modelId,
+          displayName: composition.name,
+          contents
+        };
+        if (this.options.includeDescriptions) {
+          iface.description = `Generated from HoloScript composition "${this.escapeStringValue(composition.name, "TypeScript")}"`;
+        }
+        return iface;
+      }
+      compileTemplate(template) {
+        const modelId = this.generateModelId(template.name);
+        const contents = [];
+        if (template.state) {
+          contents.push(...this.compileStateProperties(template.state));
+        }
+        if (template.actions) {
+          for (const action of template.actions) {
+            contents.push({
+              "@type": "Command",
+              name: action.name,
+              displayName: action.name,
+              description: `Action defined in template ${this.escapeStringValue(template.name, "TypeScript")}`
+            });
+          }
+        }
+        if (template.traits && this.options.includeTraitComponents) {
+          for (const trait of template.traits) {
+            const traitName = typeof trait === "string" ? trait : trait.name;
+            const component = this.traitToComponent(traitName);
+            if (component) {
+              contents.push(component);
+            }
+          }
+        }
+        const iface = {
+          "@context": this.getDtdlContext(),
+          "@type": "Interface",
+          "@id": modelId,
+          displayName: template.name,
+          contents
+        };
+        const templateExt = template;
+        if (templateExt.extends) {
+          iface.extends = [this.generateModelId(templateExt.extends)];
+        }
+        return iface;
+      }
+      compileObject(obj) {
+        const modelId = this.generateModelId(obj.name);
+        const contents = [];
+        const posProp = obj.properties.find((p) => p.key === "position");
+        if (posProp) {
+          contents.push({
+            "@type": ["Property", "Location"],
+            name: "position",
+            schema: {
+              "@type": "Object",
+              fields: [
+                { name: "x", schema: "double" },
+                { name: "y", schema: "double" },
+                { name: "z", schema: "double" }
+              ]
+            },
+            writable: true
+          });
+        }
+        for (const prop of obj.properties) {
+          if (prop.key !== "position" && prop.key !== "geometry") {
+            contents.push(this.propertyToContent(prop.key, prop.value));
+          }
+        }
+        if (this.hasTrait(obj.traits, "sensor") || this.hasTrait(obj.traits, "observable")) {
+          contents.push({
+            "@type": "Telemetry",
+            name: "sensorReading",
+            schema: "double",
+            description: "Sensor telemetry data"
+          });
+        }
+        if (obj.traits && this.options.includeTraitComponents) {
+          for (const trait of obj.traits) {
+            const traitName = this.getTraitName(trait);
+            const component = this.traitToComponent(traitName);
+            if (component) {
+              contents.push(component);
+            }
+          }
+        }
+        const iface = {
+          "@context": this.getDtdlContext(),
+          "@type": "Interface",
+          "@id": modelId,
+          displayName: obj.name,
+          contents
+        };
+        if (obj.template) {
+          iface.extends = this.generateModelId(obj.template);
+        }
+        return iface;
+      }
+      compileEnvironmentProperties(env) {
+        const props = [];
+        const envExt = env;
+        if (Array.isArray(envExt.properties)) {
+          for (const prop of envExt.properties) {
+            this.addEnvironmentProperty(props, prop.key, prop.value);
+          }
+        } else {
+          for (const key of Object.keys(envExt)) {
+            if (key !== "type") {
+              this.addEnvironmentProperty(props, key, envExt[key]);
+            }
+          }
+        }
+        return props;
+      }
+      addEnvironmentProperty(props, key, _value) {
+        if (key === "skybox") {
+          props.push({
+            "@type": "Property",
+            name: "skybox",
+            schema: "string",
+            displayName: "Skybox",
+            description: "Environment skybox setting"
+          });
+        } else if (key === "ambient_light") {
+          props.push({
+            "@type": "Property",
+            name: "ambientLight",
+            schema: "double",
+            displayName: "Ambient Light",
+            description: "Ambient light level"
+          });
+        } else if (key === "fog") {
+          props.push({
+            "@type": "Property",
+            name: "fogEnabled",
+            schema: "boolean",
+            displayName: "Fog Enabled"
+          });
+        }
+      }
+      compileStateProperties(state) {
+        const props = [];
+        for (const prop of state.properties) {
+          props.push(this.propertyToContent(prop.key, prop.value));
+        }
+        return props;
+      }
+      compileLogicCommands(logic) {
+        const commands = [];
+        const logicExt = logic;
+        const items = logicExt.handlers || logicExt.rules || [];
+        for (const item of items) {
+          const event = item.event;
+          if (event?.startsWith("on_")) {
+            commands.push({
+              "@type": "Command",
+              name: event.replace("on_", ""),
+              displayName: this.formatEventName(event),
+              description: `Event handler for ${event}`
+            });
+          }
+        }
+        return commands;
+      }
+      propertyToContent(key, value) {
+        return {
+          "@type": "Property",
+          name: this.sanitizeName(key),
+          schema: this.inferSchema(value),
+          displayName: this.formatDisplayName(key),
+          writable: true
+        };
+      }
+      createObjectRelationship(obj) {
+        return {
+          "@type": "Relationship",
+          name: `has${this.pascalCase(obj.name)}`,
+          displayName: obj.name,
+          target: this.objectNeedsInterface(obj) ? this.generateModelId(obj.name) : void 0,
+          maxMultiplicity: 1
+        };
+      }
+      traitToComponent(trait) {
+        const traitComponents = {
+          grabbable: {
+            schema: `${this.options.namespace}:component:Grabbable;${this.options.modelVersion}`,
+            description: "Allows object to be grabbed/manipulated"
+          },
+          networked: {
+            schema: `${this.options.namespace}:component:Networked;${this.options.modelVersion}`,
+            description: "Enables network synchronization"
+          },
+          physics: {
+            schema: `${this.options.namespace}:component:Physics;${this.options.modelVersion}`,
+            description: "Enables physics simulation"
+          },
+          collidable: {
+            schema: `${this.options.namespace}:component:Collidable;${this.options.modelVersion}`,
+            description: "Enables collision detection"
+          },
+          sensor: {
+            schema: `${this.options.namespace}:component:Sensor;${this.options.modelVersion}`,
+            description: "IoT sensor capabilities"
+          },
+          observable: {
+            schema: `${this.options.namespace}:component:Observable;${this.options.modelVersion}`,
+            description: "State observation capabilities"
+          }
+        };
+        const config = traitComponents[trait];
+        if (!config) return null;
+        return {
+          "@type": "Component",
+          name: trait,
+          schema: config.schema,
+          description: config.description
+        };
+      }
+      inferSchema(value) {
+        if (typeof value === "boolean") return "boolean";
+        if (typeof value === "number") {
+          return Number.isInteger(value) ? "integer" : "double";
+        }
+        if (typeof value === "string") return "string";
+        if (Array.isArray(value)) {
+          if (value.length > 0) {
+            return {
+              "@type": "Array",
+              elementSchema: this.inferSchema(value[0])
+            };
+          }
+          return { "@type": "Array", elementSchema: "double" };
+        }
+        if (typeof value === "object" && value !== null) {
+          const fields = Object.entries(value).map(([k, v]) => ({
+            name: k,
+            schema: this.inferSchema(v)
+          }));
+          return { "@type": "Object", fields };
+        }
+        return "string";
+      }
+      getDtdlContext() {
+        return this.options.dtdlVersion === 3 ? "dtmi:dtdl:context;3" : "dtmi:dtdl:context;2";
+      }
+      generateModelId(name) {
+        const sanitized = this.sanitizeName(name);
+        return `${this.options.namespace}:${sanitized};${this.options.modelVersion}`;
+      }
+      objectNeedsInterface(obj) {
+        const hasState = obj.properties.some((p) => p.key === "state" || typeof p.value === "object");
+        const complexTraitList = ["networked", "sensor", "observable", "state"];
+        const hasComplexTraits = obj.traits?.some(
+          (t) => complexTraitList.includes(this.getTraitName(t))
+        );
+        return hasState || hasComplexTraits || false;
+      }
+      sanitizeName(name) {
+        return name.replace(/[^a-zA-Z0-9_]/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
+      }
+      formatDisplayName(name) {
+        return name.replace(/_/g, " ").replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase()).trim();
+      }
+      formatEventName(event) {
+        return event.replace(/^on_/, "").replace(/_/g, " ").replace(/^./, (s) => s.toUpperCase());
+      }
+      pascalCase(name) {
+        return name.replace(/[^a-zA-Z0-9]/g, " ").split(" ").map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
+      }
+    };
+    DTDL_TRAIT_COMPONENTS = [
+      {
+        "@context": "dtmi:dtdl:context;3",
+        "@type": "Interface",
+        "@id": "dtmi:holoscript:component:Grabbable;1",
+        displayName: "Grabbable",
+        description: "Component for objects that can be grabbed in VR/AR",
+        contents: [
+          { "@type": "Property", name: "isGrabbed", schema: "boolean", writable: false },
+          { "@type": "Property", name: "grabDistance", schema: "double", writable: true }
+        ]
+      },
+      {
+        "@context": "dtmi:dtdl:context;3",
+        "@type": "Interface",
+        "@id": "dtmi:holoscript:component:Networked;1",
+        displayName: "Networked",
+        description: "Component for network-synchronized objects",
+        contents: [
+          { "@type": "Property", name: "networkId", schema: "string", writable: false },
+          { "@type": "Property", name: "syncRate", schema: "integer", writable: true },
+          { "@type": "Property", name: "ownerId", schema: "string", writable: false }
+        ]
+      },
+      {
+        "@context": "dtmi:dtdl:context;3",
+        "@type": "Interface",
+        "@id": "dtmi:holoscript:component:Physics;1",
+        displayName: "Physics",
+        description: "Component for physics-enabled objects",
+        contents: [
+          { "@type": "Property", name: "mass", schema: "double", writable: true },
+          { "@type": "Property", name: "friction", schema: "double", writable: true },
+          { "@type": "Property", name: "restitution", schema: "double", writable: true },
+          { "@type": "Property", name: "isKinematic", schema: "boolean", writable: true }
+        ]
+      },
+      {
+        "@context": "dtmi:dtdl:context;3",
+        "@type": "Interface",
+        "@id": "dtmi:holoscript:component:Sensor;1",
+        displayName: "Sensor",
+        description: "Component for IoT sensor capabilities",
+        contents: [
+          { "@type": "Property", name: "sensorType", schema: "string", writable: false },
+          { "@type": "Telemetry", name: "value", schema: "double" },
+          { "@type": "Telemetry", name: "timestamp", schema: "dateTime" }
+        ]
+      }
+    ];
+    DTDLCompiler_default = DTDLCompiler;
+  }
+});
+
+export { DTDLCompiler, DTDLCompiler_default, DTDLCompiler_exports, DTDL_TRAIT_COMPONENTS, init_DTDLCompiler };
+//# sourceMappingURL=chunk-J6M4FPK5.js.map
+//# sourceMappingURL=chunk-J6M4FPK5.js.map