@holoscript/core 1.0.0-alpha.1 → 1.0.0-alpha.2

package/dist/index.js

@@ -1,699 +0,0 @@
-export { HoloScriptTypeChecker, createTypeChecker } from './chunk-KWYIVRIH.js';
-export { HoloScriptDebugger, createDebugger } from './chunk-LKH4ZAN6.js';
-export { HoloScriptCodeParser } from './chunk-723TPVHD.js';
-import { HoloScriptRuntime } from './chunk-HQZ3HUMY.js';
-export { HoloScriptRuntime } from './chunk-HQZ3HUMY.js';
-import { logger } from './chunk-SATNCODL.js';
-export { ConsoleLogger, NoOpLogger, enableConsoleLogging, logger, resetLogger, setHoloScriptLogger } from './chunk-SATNCODL.js';
-
-// src/HoloScript2DParser.ts
-var UI_SECURITY_CONFIG = {
-  maxUIElements: 500,
-  maxNestingDepth: 10,
-  allowedEventHandlers: ["onClick", "onChange", "onSubmit", "onFocus", "onBlur", "onHover"]
-};
-var HoloScript2DParser = class {
-  constructor() {
-    this.uiElements = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Parse 2D UI element from HoloScript code
-   */
-  parse2DElement(code, depth = 0) {
-    if (depth > UI_SECURITY_CONFIG.maxNestingDepth) {
-      logger.warn("Max nesting depth exceeded", { depth });
-      return null;
-    }
-    const trimmedCode = code.trim();
-    const lines = trimmedCode.split("\n");
-    if (lines.length === 0) return null;
-    const firstLine = lines[0].trim();
-    const headerMatch = firstLine.match(/^([\w-]+)\s+(\w+)\s*\{/);
-    if (!headerMatch) {
-      logger.warn("Invalid 2D element syntax", { line: firstLine });
-      return null;
-    }
-    const [, elementType, name] = headerMatch;
-    if (!this.isValidUIElementType(elementType)) {
-      logger.warn("Invalid UI element type", { elementType });
-      return null;
-    }
-    const startIndex = trimmedCode.indexOf("{");
-    const endIndex = trimmedCode.lastIndexOf("}");
-    if (startIndex === -1 || endIndex === -1 || endIndex <= startIndex) {
-      return null;
-    }
-    const innerContent = trimmedCode.slice(startIndex + 1, endIndex).trim();
-    const innerLines = this.splitIntoLogicalBlocks(innerContent);
-    const properties = {};
-    const events = {};
-    const children = [];
-    for (const block of innerLines) {
-      const line = block.trim();
-      if (!line) continue;
-      if (line.includes("{")) {
-        const childNode = this.parse2DElement(line, depth + 1);
-        if (childNode) children.push(childNode);
-        continue;
-      }
-      const propMatch = line.match(/^(\w+):\s*(.+)$/);
-      if (propMatch) {
-        const [, key, rawValue] = propMatch;
-        if (UI_SECURITY_CONFIG.allowedEventHandlers.includes(key)) {
-          events[key] = rawValue.trim();
-        } else {
-          properties[key] = this.parsePropertyValue(rawValue);
-        }
-      }
-    }
-    const node = {
-      type: "2d-element",
-      elementType,
-      name,
-      properties: { ...this.getDefaultProperties(elementType), ...properties },
-      events: Object.keys(events).length > 0 ? events : void 0,
-      children: children.length > 0 ? children : void 0
-    };
-    if (depth === 0) {
-      if (this.uiElements.size >= UI_SECURITY_CONFIG.maxUIElements) {
-        logger.warn("Max UI elements limit reached");
-        return null;
-      }
-      this.uiElements.set(name, node);
-    }
-    return node;
-  }
-  splitIntoLogicalBlocks(content) {
-    const blocks = [];
-    let currentBlock = "";
-    let bracketDepth = 0;
-    for (let i = 0; i < content.length; i++) {
-      const char = content[i];
-      if (char === "{") bracketDepth++;
-      if (char === "}") bracketDepth--;
-      currentBlock += char;
-      if (bracketDepth === 0) {
-        if (char === "\n" || i === content.length - 1) {
-          const trimmed = currentBlock.trim();
-          if (trimmed) blocks.push(trimmed);
-          currentBlock = "";
-        }
-      }
-    }
-    const finalTrimmed = currentBlock.trim();
-    if (finalTrimmed) blocks.push(finalTrimmed);
-    return blocks;
-  }
-  /**
-   * Parse voice command for 2D UI creation
-   */
-  parse2DVoiceCommand(command) {
-    const tokens = command.toLowerCase().trim().split(/\s+/);
-    if (tokens.length < 3) return null;
-    const action = tokens[0];
-    const elementType = tokens[1];
-    const name = tokens[2];
-    if (action !== "create" && action !== "add") return null;
-    if (!this.isValidUIElementType(elementType)) return null;
-    const node = {
-      type: "2d-element",
-      elementType,
-      name,
-      properties: this.getDefaultProperties(elementType)
-    };
-    this.uiElements.set(name, node);
-    return node;
-  }
-  /**
-   * Parse gesture for 2D UI interaction
-   */
-  parse2DGesture(gestureType, position) {
-    switch (gestureType) {
-      case "tap":
-        return this.createQuick2DElement("button", `button_${Date.now()}`, position);
-      case "double-tap":
-        return this.createQuick2DElement("textinput", `input_${Date.now()}`, position);
-      case "long-press":
-        return this.createQuick2DElement("panel", `panel_${Date.now()}`, position);
-      default:
-        return null;
-    }
-  }
-  createQuick2DElement(elementType, name, position) {
-    const node = {
-      type: "2d-element",
-      elementType,
-      name,
-      properties: {
-        ...this.getDefaultProperties(elementType),
-        x: position.x,
-        y: position.y
-      }
-    };
-    this.uiElements.set(name, node);
-    return node;
-  }
-  isValidUIElementType(type) {
-    const validTypes = [
-      "canvas",
-      "button",
-      "textinput",
-      "panel",
-      "text",
-      "image",
-      "list",
-      "modal",
-      "slider",
-      "toggle",
-      "dropdown",
-      "flex-container",
-      "grid-container",
-      "scroll-view",
-      "tab-view"
-    ];
-    return validTypes.includes(type);
-  }
-  parsePropertyValue(value) {
-    const trimmed = value.trim();
-    if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
-      return trimmed.slice(1, -1);
-    }
-    if (!isNaN(parseFloat(trimmed)) && isFinite(parseFloat(trimmed))) {
-      return parseFloat(trimmed);
-    }
-    if (trimmed === "true") return true;
-    if (trimmed === "false") return false;
-    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
-      const items = trimmed.slice(1, -1).split(",").map(
-        (item) => this.parsePropertyValue(item.trim())
-      );
-      return items;
-    }
-    return trimmed;
-  }
-  getDefaultProperties(elementType) {
-    const defaults = {
-      "canvas": { width: 800, height: 600, backgroundColor: "#ffffff" },
-      "button": { text: "Button", width: 120, height: 40, backgroundColor: "#007bff", color: "#ffffff", borderRadius: 4 },
-      "textinput": { placeholder: "", width: 200, height: 36, fontSize: 14, borderColor: "#cccccc", borderWidth: 1, borderRadius: 4 },
-      "panel": { width: 200, height: 200, backgroundColor: "#f0f0f0", borderRadius: 0 },
-      "text": { content: "Text", fontSize: 16, color: "#000000", fontFamily: "sans-serif" },
-      "image": { src: "", width: 100, height: 100, fit: "cover" },
-      "list": { items: [], itemHeight: 40, width: 200, height: 300 },
-      "modal": { title: "Modal", width: 400, height: 300, visible: false, backgroundColor: "#ffffff" },
-      "slider": { min: 0, max: 100, value: 50, width: 200 },
-      "toggle": { checked: false, width: 50, height: 24 },
-      "dropdown": { options: [], selected: null, width: 200 },
-      "flex-container": { direction: "row", gap: 10, padding: 10 },
-      "grid-container": { columns: 3, gap: 10, padding: 10 },
-      "scroll-view": { width: 300, height: 400, scrollDirection: "vertical" },
-      "tab-view": { tabs: [], activeTabId: null, tabPosition: "top", width: 400, height: 300 }
-    };
-    return { ...defaults[elementType] };
-  }
-  getUIElements() {
-    return new Map(this.uiElements);
-  }
-  findElement(name) {
-    return this.uiElements.get(name) || null;
-  }
-  clear() {
-    this.uiElements.clear();
-  }
-};
-
-// src/HoloScriptParser.ts
-var HOLOSCRIPT_SECURITY_CONFIG = {
-  maxCommandLength: 1e3,
-  maxTokens: 100,
-  suspiciousKeywords: [
-    "process",
-    "require",
-    "eval",
-    "import",
-    "constructor",
-    "prototype",
-    "__proto__",
-    "fs",
-    "child_process",
-    "exec",
-    "spawn",
-    "fetch",
-    "xmlhttprequest"
-  ],
-  allowedUIElements: [
-    "canvas",
-    "button",
-    "textinput",
-    "panel",
-    "text",
-    "image",
-    "list",
-    "modal",
-    "slider",
-    "toggle",
-    "dropdown",
-    "flex-container",
-    "grid-container",
-    "scroll-view"
-  ]
-};
-var HoloScriptParser = class {
-  constructor() {
-    this.ast = [];
-    this.parser2D = new HoloScript2DParser();
-  }
-  /**
-   * Parse voice command into AST nodes
-   */
-  parseVoiceCommand(command) {
-    if (command.command.length > HOLOSCRIPT_SECURITY_CONFIG.maxCommandLength) {
-      logger.warn("Command too long", {
-        length: command.command.length,
-        limit: HOLOSCRIPT_SECURITY_CONFIG.maxCommandLength
-      });
-      return [];
-    }
-    const rawTokens = this.tokenizeCommand(command.command.toLowerCase());
-    const tokens = this.sanitizeTokens(rawTokens);
-    if (tokens.length === 0) return [];
-    if (tokens.length > HOLOSCRIPT_SECURITY_CONFIG.maxTokens) {
-      logger.warn("Too many tokens in command", {
-        tokenCount: tokens.length,
-        limit: HOLOSCRIPT_SECURITY_CONFIG.maxTokens
-      });
-      return [];
-    }
-    const commandType = tokens[0];
-    if ((commandType === "create" || commandType === "add") && tokens.length > 1) {
-      const elementType = tokens[1];
-      if (HOLOSCRIPT_SECURITY_CONFIG.allowedUIElements.includes(elementType)) {
-        return this.parse2DUICommand(command.command);
-      }
-    }
-    switch (commandType) {
-      case "create":
-      case "summon":
-        return this.parseCreateCommand(tokens.slice(1), command.spatialContext);
-      case "connect":
-        return this.parseConnectCommand(tokens.slice(1));
-      case "execute":
-      case "run":
-        return this.parseExecuteCommand(tokens.slice(1));
-      case "debug":
-        return this.parseDebugCommand(tokens.slice(1));
-      case "visualize":
-        return this.parseVisualizeCommand(tokens.slice(1));
-      default:
-        return this.parseGenericCommand(tokens);
-    }
-  }
-  parse2DUICommand(command) {
-    const ui2DNode = this.parser2D.parse2DVoiceCommand(command);
-    if (!ui2DNode) return [];
-    const astNode = {
-      type: "2d-ui",
-      uiElementType: ui2DNode.elementType,
-      name: ui2DNode.name,
-      properties: ui2DNode.properties,
-      events: ui2DNode.events,
-      children: ui2DNode.children
-    };
-    return [astNode];
-  }
-  /**
-   * Parse gesture input
-   */
-  parseGesture(gesture) {
-    switch (gesture.type) {
-      case "pinch":
-        return this.parsePinchGesture(gesture);
-      case "swipe":
-        return this.parseSwipeGesture(gesture);
-      case "rotate":
-        return this.parseRotateGesture(gesture);
-      case "grab":
-        return this.parseGrabGesture(gesture);
-      default:
-        return [];
-    }
-  }
-  parseCreateCommand(tokens, position) {
-    if (tokens.length < 2) return [];
-    const shape = tokens[0];
-    const name = tokens[1];
-    switch (shape) {
-      case "orb":
-      case "sphere":
-        return [this.createOrbNode(name, position)];
-      case "function":
-        return [this.createFunctionNode(name, tokens.slice(2), position)];
-      case "gate":
-        return [this.createGateNode(name, tokens.slice(2), position)];
-      case "stream":
-        return [this.createStreamNode(name, tokens.slice(2), position)];
-      default:
-        return [this.createGenericNode(shape, name, position)];
-    }
-  }
-  parseConnectCommand(tokens) {
-    if (tokens.length < 3) return [];
-    const from = tokens[0];
-    const to = tokens[2];
-    const dataType = tokens.length > 3 ? tokens[3] : "any";
-    return [{
-      type: "connection",
-      from,
-      to,
-      dataType,
-      bidirectional: tokens.includes("bidirectional") || tokens.includes("both")
-    }];
-  }
-  createOrbNode(name, position) {
-    return {
-      type: "orb",
-      name,
-      position: position || { x: 0, y: 0, z: 0 },
-      hologram: {
-        shape: "orb",
-        color: "#00ffff",
-        size: 1,
-        glow: true,
-        interactive: true
-      },
-      properties: {},
-      methods: []
-    };
-  }
-  createFunctionNode(name, params, position) {
-    const parameters = [];
-    let inParams = false;
-    for (const param of params) {
-      if (param === "with" || param === "parameters") {
-        inParams = true;
-        continue;
-      }
-      if (inParams && param !== "do" && param !== "execute") {
-        parameters.push({
-          type: "parameter",
-          name: param,
-          dataType: "any"
-        });
-      }
-    }
-    return {
-      type: "function",
-      name,
-      parameters,
-      body: [],
-      position: position || { x: 0, y: 0, z: 0 },
-      hologram: {
-        shape: "cube",
-        color: "#ff6b35",
-        size: 1.5,
-        glow: true,
-        interactive: true
-      }
-    };
-  }
-  createGateNode(_name, params, position) {
-    const condition = params.join(" ").replace("condition", "").trim();
-    return {
-      type: "gate",
-      condition,
-      truePath: [],
-      falsePath: [],
-      position: position || { x: 0, y: 0, z: 0 },
-      hologram: {
-        shape: "pyramid",
-        color: "#4ecdc4",
-        size: 1,
-        glow: true,
-        interactive: true
-      }
-    };
-  }
-  createStreamNode(name, params, position) {
-    return {
-      type: "stream",
-      name,
-      source: params[0] || "unknown",
-      transformations: [],
-      position: position || { x: 0, y: 0, z: 0 },
-      hologram: {
-        shape: "cylinder",
-        color: "#45b7d1",
-        size: 2,
-        glow: true,
-        interactive: true
-      }
-    };
-  }
-  createGenericNode(shape, name, position) {
-    return {
-      type: shape,
-      name,
-      position: position || { x: 0, y: 0, z: 0 },
-      hologram: {
-        shape,
-        color: "#ffffff",
-        size: 1,
-        glow: false,
-        interactive: true
-      }
-    };
-  }
-  parsePinchGesture(gesture) {
-    return [{
-      type: "create",
-      position: gesture.position,
-      hologram: { shape: "orb", color: "#ff0000", size: 0.5, glow: true, interactive: true }
-    }];
-  }
-  parseSwipeGesture(gesture) {
-    if (!gesture.direction) return [];
-    return [{
-      type: "connect",
-      position: gesture.position,
-      hologram: { shape: "cylinder", color: "#00ff00", size: gesture.magnitude, glow: true, interactive: false }
-    }];
-  }
-  parseRotateGesture(gesture) {
-    return [{
-      type: "modify",
-      position: gesture.position,
-      hologram: { shape: "sphere", color: "#ffff00", size: 0.8, glow: true, interactive: true }
-    }];
-  }
-  parseGrabGesture(gesture) {
-    return [{
-      type: "select",
-      position: gesture.position,
-      hologram: { shape: "cube", color: "#ff00ff", size: 0.3, glow: true, interactive: true }
-    }];
-  }
-  tokenizeCommand(command) {
-    return command.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((token) => token.length > 0);
-  }
-  sanitizeTokens(tokens) {
-    return tokens.filter((token) => {
-      const isSuspicious = HOLOSCRIPT_SECURITY_CONFIG.suspiciousKeywords.some(
-        (keyword) => token.includes(keyword)
-      );
-      if (isSuspicious) {
-        logger.warn("Suspicious token blocked", { token });
-        return false;
-      }
-      return true;
-    });
-  }
-  parseExecuteCommand(tokens) {
-    return [{
-      type: "execute",
-      target: tokens[0] || "unknown",
-      hologram: { shape: "sphere", color: "#ff4500", size: 1.2, glow: true, interactive: false }
-    }];
-  }
-  parseDebugCommand(tokens) {
-    return [{
-      type: "debug",
-      target: tokens[0] || "program",
-      hologram: { shape: "pyramid", color: "#ff1493", size: 0.8, glow: true, interactive: true }
-    }];
-  }
-  parseVisualizeCommand(tokens) {
-    return [{
-      type: "visualize",
-      target: tokens[0] || "data",
-      hologram: { shape: "cylinder", color: "#32cd32", size: 1.5, glow: true, interactive: true }
-    }];
-  }
-  parseGenericCommand(tokens) {
-    return [{
-      type: "generic",
-      command: tokens.join(" "),
-      hologram: { shape: "orb", color: "#808080", size: 0.5, glow: false, interactive: true }
-    }];
-  }
-  getAST() {
-    return [...this.ast];
-  }
-  addNode(node) {
-    this.ast.push(node);
-  }
-  clear() {
-    this.ast = [];
-  }
-  findNode(name) {
-    return this.ast.find((node) => "name" in node && node.name === name) || null;
-  }
-  getNodesAtPosition(position, radius = 1) {
-    return this.ast.filter((node) => {
-      if (!node.position) return false;
-      const distance = Math.sqrt(
-        Math.pow(node.position.x - position.x, 2) + Math.pow(node.position.y - position.y, 2) + Math.pow(node.position.z - position.z, 2)
-      );
-      return distance <= radius;
-    });
-  }
-  parse2DCode(code) {
-    return this.parser2D.parse2DElement(code);
-  }
-  get2DParser() {
-    return this.parser2D;
-  }
-};
-
-// src/index.ts
-var HOLOSCRIPT_VERSION = "1.0.0-alpha.1";
-var HOLOSCRIPT_SUPPORTED_PLATFORMS = [
-  "WebXR",
-  "Oculus Quest",
-  "HTC Vive",
-  "Valve Index",
-  "Apple Vision Pro",
-  "Windows Mixed Reality"
-];
-var HOLOSCRIPT_VOICE_COMMANDS = [
-  // 3D VR Commands
-  "create orb [name]",
-  "summon function [name]",
-  "connect [from] to [to]",
-  "execute [function]",
-  "debug program",
-  "visualize [data]",
-  "gate [condition]",
-  "stream [source] through [transformations]",
-  // 2D UI Commands
-  "create button [name]",
-  "add textinput [name]",
-  "create panel [name]",
-  "add slider [name]"
-];
-var HOLOSCRIPT_GESTURES = [
-  "pinch - create object",
-  "swipe - connect objects",
-  "rotate - modify properties",
-  "grab - select object",
-  "spread - expand view",
-  "fist - execute action"
-];
-var HOLOSCRIPT_DEMO_SCRIPTS = {
-  helloWorld: `orb greeting {
-  message: "Hello, HoloScript World!"
-  color: "#00ffff"
-  glow: true
-}
-
-function displayGreeting() {
-  show greeting
-}`,
-  aiAgent: `orb agentCore {
-  personality: "helpful"
-  capabilities: ["conversation", "problem_solving", "learning"]
-  energy: 100
-}
-
-function processQuery(query: string): string {
-  analyze query
-  generate response
-  return response
-}`,
-  neuralNetwork: `orb inputLayer { neurons: 784 }
-orb hiddenLayer { neurons: 128 }
-orb outputLayer { neurons: 10 }
-
-connect inputLayer to hiddenLayer as "weights"
-connect hiddenLayer to outputLayer as "weights"
-
-function trainNetwork(data: array): object {
-  forward_pass data
-  calculate_loss
-  backward_pass
-  update_weights
-  return metrics
-}`,
-  loginForm: `button loginBtn {
-  text: "Login"
-  x: 100
-  y: 150
-  width: 200
-  height: 40
-  onClick: handleLogin
-}
-
-textinput usernameInput {
-  placeholder: "Username"
-  x: 100
-  y: 50
-  width: 200
-  height: 36
-}
-
-textinput passwordInput {
-  placeholder: "Password"
-  x: 100
-  y: 100
-  width: 200
-  height: 36
-}`,
-  dashboard: `panel sidebar {
-  x: 0
-  y: 0
-  width: 200
-  height: 600
-  backgroundColor: "#2c3e50"
-}
-
-text title {
-  content: "Dashboard"
-  x: 220
-  y: 20
-  fontSize: 24
-  color: "#34495e"
-}
-
-button refreshBtn {
-  text: "Refresh Data"
-  x: 220
-  y: 60
-  onClick: refreshData
-}`
-};
-function createHoloScriptEnvironment() {
-  return {
-    parser: new HoloScriptParser(),
-    runtime: new HoloScriptRuntime(),
-    version: HOLOSCRIPT_VERSION
-  };
-}
-function isHoloScriptSupported() {
-  if (typeof globalThis === "undefined") return false;
-  const win = globalThis;
-  if (!win.window) return false;
-  return !!(win.window.navigator?.xr || win.window.navigator?.getVRDisplays || win.window.webkitGetUserMedia);
-}
-
-export { HOLOSCRIPT_DEMO_SCRIPTS, HOLOSCRIPT_GESTURES, HOLOSCRIPT_SUPPORTED_PLATFORMS, HOLOSCRIPT_VERSION, HOLOSCRIPT_VOICE_COMMANDS, HoloScript2DParser, HoloScriptParser, createHoloScriptEnvironment, isHoloScriptSupported };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map