@holoscript/core 6.0.3 → 7.0.0

package/dist/chunk-ZL6VJ6SN.js

@@ -1,421 +0,0 @@
-import { init_CompilerBase, init_ANSNamespace, CompilerBase, ANSCapabilityPath } from './chunk-QWKUKVRE.js';
-import { __export, __esm } from './chunk-32TWR3HE.js';
-
-// 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();
-    init_ANSNamespace();
-    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-ZL6VJ6SN.js.map
-//# sourceMappingURL=chunk-ZL6VJ6SN.js.map