@holoscript/core 6.0.2 → 6.0.4

package/dist/chunk-CN4NOESF.cjs

@@ -1,416 +0,0 @@
-'use strict';
-
-// src/wot/ThingDescriptionGenerator.ts
-var ThingDescriptionGenerator = class {
-  constructor(options = {}) {
-    this.options = {
-      baseUrl: options.baseUrl || "",
-      contentType: options.contentType || "application/json",
-      defaultObservable: options.defaultObservable ?? true,
-      securityDefinitions: options.securityDefinitions
-    };
-  }
-  /**
-   * Generate a Thing Description from a HoloScript node with @wot_thing trait
-   */
-  generate(node) {
-    const wotTrait = this.findWoTTrait(node);
-    if (!wotTrait) {
-      return null;
-    }
-    const config = this.parseWoTConfig(wotTrait);
-    const stateProperties = this.extractStateProperties(node);
-    const actions = this.extractActions(node);
-    const events = this.extractEvents(node);
-    const td = {
-      "@context": "https://www.w3.org/2022/wot/td/v1.1",
-      id: config.id || `urn:holoscript:${node.name || "thing"}`,
-      title: config.title || node.name || "Unnamed Thing",
-      security: "default",
-      securityDefinitions: this.buildSecurityDefinitions(config.security)
-    };
-    if (config.description) {
-      td.description = config.description;
-    }
-    if (config.base || this.options.baseUrl) {
-      td.base = config.base || this.options.baseUrl;
-    }
-    if (config.version) {
-      td.version = { instance: config.version };
-    }
-    if (Object.keys(stateProperties).length > 0) {
-      td.properties = stateProperties;
-    }
-    if (Object.keys(actions).length > 0) {
-      td.actions = actions;
-    }
-    if (Object.keys(events).length > 0) {
-      td.events = events;
-    }
-    return td;
-  }
-  /**
-   * Generate Thing Descriptions for all nodes with @wot_thing trait
-   */
-  generateAll(nodes) {
-    const results = [];
-    const processNode = (node) => {
-      const td = this.generate(node);
-      if (td) {
-        results.push(td);
-      }
-      if (node.children) {
-        for (const child of node.children) {
-          processNode(child);
-        }
-      }
-    };
-    for (const node of nodes) {
-      processNode(node);
-    }
-    return results;
-  }
-  /**
-   * Find @wot_thing directive in node
-   */
-  findWoTTrait(node) {
-    if (!node.directives) {
-      return null;
-    }
-    return node.directives.find(
-      (d) => d.type === "trait" && d.name === "wot_thing" || d.type === "directive" && d.name === "wot_thing"
-    ) || null;
-  }
-  /**
-   * Parse @wot_thing config from directive
-   */
-  parseWoTConfig(directive) {
-    const dir = directive;
-    const args = dir.args || dir.config || {};
-    return {
-      title: String(args.title || ""),
-      description: args.description ? String(args.description) : void 0,
-      security: args.security || "nosec",
-      base: args.base ? String(args.base) : void 0,
-      id: args.id ? String(args.id) : void 0,
-      version: args.version ? String(args.version) : void 0
-    };
-  }
-  /**
-   * Extract TD properties from @state block
-   */
-  extractStateProperties(node) {
-    const properties = {};
-    if (!node.directives) {
-      return properties;
-    }
-    const stateDirective = node.directives.find(
-      (d) => d.type === "state" || d.type === "directive" && d.name === "state"
-    );
-    if (!stateDirective || !stateDirective.body) {
-      if (node.properties?.state && typeof node.properties.state === "object") {
-        return this.mapStateToProperties(node.properties.state);
-      }
-      return properties;
-    }
-    const rawBody = stateDirective.body;
-    const stateBody = typeof rawBody === "object" && rawBody !== null ? rawBody : {};
-    return this.mapStateToProperties(stateBody);
-  }
-  /**
-   * Map state object to TD properties
-   */
-  mapStateToProperties(state) {
-    const properties = {};
-    for (const [key, value] of Object.entries(state)) {
-      const property = {
-        type: this.inferType(value),
-        observable: this.options.defaultObservable,
-        forms: [
-          {
-            href: `${this.options.baseUrl}/properties/${key}`,
-            contentType: this.options.contentType,
-            op: ["readproperty", "writeproperty"]
-          }
-        ]
-      };
-      if (value !== void 0 && value !== null) {
-        property.default = value;
-      }
-      if (typeof value === "number") {
-        if (Number.isInteger(value)) {
-          property.type = "integer";
-        }
-      }
-      if (Array.isArray(value)) {
-        property.type = "array";
-        if (value.length > 0) {
-          property.items = { type: this.inferType(value[0]) };
-        }
-      }
-      if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-        property.type = "object";
-        property.properties = {};
-        for (const [subKey, subValue] of Object.entries(value)) {
-          property.properties[subKey] = { type: this.inferType(subValue) };
-        }
-      }
-      properties[key] = property;
-    }
-    return properties;
-  }
-  /**
-   * Extract TD actions from @on_* handlers
-   */
-  extractActions(node) {
-    const actions = {};
-    if (!node.directives) {
-      return actions;
-    }
-    const actionPatterns = [
-      /^on_click$/,
-      /^on_grab$/,
-      /^on_release$/,
-      /^on_hover$/,
-      /^on_action$/,
-      /^on_command$/,
-      /^on_invoke$/,
-      /^on_call$/
-    ];
-    for (const directive of node.directives) {
-      const d = directive;
-      if (directive.type !== "lifecycle" && d.hook === void 0) {
-        continue;
-      }
-      const hookName = d.hook || d.name;
-      if (!hookName) continue;
-      const isAction = actionPatterns.some((pattern) => pattern.test(hookName));
-      if (!isAction) continue;
-      const actionName = hookName.replace(/^on_/, "");
-      actions[actionName] = {
-        title: this.toTitleCase(actionName),
-        description: `Invoke ${actionName} action`,
-        safe: false,
-        idempotent: false,
-        forms: [
-          {
-            href: `${this.options.baseUrl}/actions/${actionName}`,
-            contentType: this.options.contentType,
-            op: "invokeaction"
-          }
-        ]
-      };
-      if (d.args && typeof d.args === "object") {
-        actions[actionName].input = {
-          type: "object",
-          properties: this.extractInputSchema(d.args)
-        };
-      }
-    }
-    return actions;
-  }
-  /**
-   * Extract TD events from emit() calls
-   */
-  extractEvents(node) {
-    const events = {};
-    if (!node.directives) {
-      return events;
-    }
-    const observableDirectives = node.directives.filter(
-      (d) => d.type === "directive" && (d.name === "observable" || d.name === "event" || d.name === "emit")
-    );
-    for (const directive of observableDirectives) {
-      const dirExt = directive;
-      const args = dirExt.args || dirExt.config || {};
-      const eventName = args.name || args.event || "change";
-      events[String(eventName)] = {
-        title: this.toTitleCase(String(eventName)),
-        description: `${eventName} event`,
-        forms: [
-          {
-            href: `${this.options.baseUrl}/events/${eventName}`,
-            contentType: this.options.contentType,
-            subprotocol: "sse",
-            op: "subscribeevent"
-          }
-        ]
-      };
-      if (args.data && typeof args.data === "object") {
-        events[String(eventName)].data = {
-          type: "object",
-          properties: this.extractInputSchema(args.data)
-        };
-      }
-    }
-    const emitPattern = /emit\s*\(\s*['"]([^'"]+)['"]/g;
-    for (const directive of node.directives) {
-      const dirBody = directive.body;
-      if (dirBody && typeof dirBody === "string") {
-        let match;
-        while ((match = emitPattern.exec(dirBody)) !== null) {
-          const eventName = match[1];
-          if (!events[eventName]) {
-            events[eventName] = {
-              title: this.toTitleCase(eventName),
-              description: `${eventName} event`,
-              forms: [
-                {
-                  href: `${this.options.baseUrl}/events/${eventName}`,
-                  contentType: this.options.contentType,
-                  subprotocol: "sse",
-                  op: "subscribeevent"
-                }
-              ]
-            };
-          }
-        }
-      }
-    }
-    return events;
-  }
-  /**
-   * Build security definitions based on config
-   */
-  buildSecurityDefinitions(security) {
-    if (this.options.securityDefinitions) {
-      return this.options.securityDefinitions;
-    }
-    const definitions = {};
-    switch (security) {
-      case "basic":
-        definitions.default = {
-          scheme: "basic",
-          in: "header"
-        };
-        break;
-      case "bearer":
-        definitions.default = {
-          scheme: "bearer",
-          in: "header",
-          format: "jwt"
-        };
-        break;
-      case "oauth2":
-        definitions.default = {
-          scheme: "oauth2",
-          flow: "code"
-        };
-        break;
-      case "apikey":
-        definitions.default = {
-          scheme: "apikey",
-          in: "header",
-          name: "X-API-Key"
-        };
-        break;
-      case "nosec":
-      default:
-        definitions.default = {
-          scheme: "nosec"
-        };
-        break;
-    }
-    return definitions;
-  }
-  /**
-   * Extract input schema from args object
-   */
-  extractInputSchema(args) {
-    const schema = {};
-    for (const [key, value] of Object.entries(args)) {
-      schema[key] = { type: this.inferType(value) };
-    }
-    return schema;
-  }
-  /**
-   * Infer JSON Schema type from value
-   */
-  inferType(value) {
-    if (value === null) return "null";
-    if (typeof value === "boolean") return "boolean";
-    if (typeof value === "number") {
-      return Number.isInteger(value) ? "integer" : "number";
-    }
-    if (typeof value === "string") return "string";
-    if (Array.isArray(value)) return "array";
-    if (typeof value === "object") return "object";
-    return "string";
-  }
-  /**
-   * Convert snake_case or camelCase to Title Case
-   */
-  toTitleCase(str) {
-    return str.replace(/_/g, " ").replace(/([A-Z])/g, " $1").replace(/^\s+/, "").split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
-  }
-};
-function generateThingDescription(node, options) {
-  const generator = new ThingDescriptionGenerator(options);
-  return generator.generate(node);
-}
-function generateAllThingDescriptions(nodes, options) {
-  const generator = new ThingDescriptionGenerator(options);
-  return generator.generateAll(nodes);
-}
-function serializeThingDescription(td, pretty = true) {
-  return JSON.stringify(td, null, pretty ? 2 : 0);
-}
-function validateThingDescription(td) {
-  const errors = [];
-  if (!td["@context"]) {
-    errors.push("Missing required field '@context'");
-  }
-  if (!td.title) {
-    errors.push("Missing required field 'title'");
-  }
-  if (!td.security) {
-    errors.push("Missing required field 'security'");
-  }
-  if (!td.securityDefinitions) {
-    errors.push("Missing required field 'securityDefinitions'");
-  }
-  if (td.security && td.securityDefinitions) {
-    const securityNames = Array.isArray(td.security) ? td.security : [td.security];
-    for (const name of securityNames) {
-      if (!td.securityDefinitions[name]) {
-        errors.push(`Security definition '${name}' not found in securityDefinitions`);
-      }
-    }
-  }
-  const validateForms = (forms) => {
-    if (forms) {
-      for (const form of forms) {
-        if (!form.href) {
-          errors.push("Form missing required href");
-        }
-      }
-    }
-  };
-  if (td.properties) {
-    for (const prop of Object.values(td.properties)) {
-      validateForms(prop.forms);
-    }
-  }
-  if (td.actions) {
-    for (const action of Object.values(td.actions)) {
-      validateForms(action.forms);
-    }
-  }
-  if (td.events) {
-    for (const event of Object.values(td.events)) {
-      validateForms(event.forms);
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    errors
-  };
-}
-
-exports.ThingDescriptionGenerator = ThingDescriptionGenerator;
-exports.generateAllThingDescriptions = generateAllThingDescriptions;
-exports.generateThingDescription = generateThingDescription;
-exports.serializeThingDescription = serializeThingDescription;
-exports.validateThingDescription = validateThingDescription;
-//# sourceMappingURL=chunk-CN4NOESF.cjs.map
-//# sourceMappingURL=chunk-CN4NOESF.cjs.map