@esengine/blueprint 4.4.0 → 4.5.0

package/dist/index.js

@@ -98,6 +98,784 @@ function validateBlueprintAsset(asset) {
 }
 __name(validateBlueprintAsset, "validateBlueprintAsset");
 
+// src/types/schema.ts
+var _SchemaRegistry = class _SchemaRegistry {
+  /**
+   * @zh 注册 Schema
+   * @en Register a schema
+   */
+  static register(id, schema) {
+    this.schemas.set(id, schema);
+  }
+  /**
+   * @zh 获取 Schema
+   * @en Get a schema
+   */
+  static get(id) {
+    return this.schemas.get(id);
+  }
+  /**
+   * @zh 解析引用，返回实际 Schema
+   * @en Resolve reference, return actual schema
+   */
+  static resolve(schema) {
+    if (schema.type === "ref") {
+      const resolved = this.schemas.get(schema.ref);
+      if (!resolved) {
+        console.warn(`[SchemaRegistry] Schema not found: ${schema.ref}`);
+        return {
+          type: "primitive",
+          primitive: "any"
+        };
+      }
+      return this.resolve(resolved);
+    }
+    return schema;
+  }
+  /**
+   * @zh 检查 Schema 是否已注册
+   * @en Check if schema is registered
+   */
+  static has(id) {
+    return this.schemas.has(id);
+  }
+  /**
+   * @zh 获取所有已注册的 Schema ID
+   * @en Get all registered schema IDs
+   */
+  static keys() {
+    return Array.from(this.schemas.keys());
+  }
+  /**
+   * @zh 清空注册表
+   * @en Clear registry
+   */
+  static clear() {
+    this.schemas.clear();
+  }
+};
+__name(_SchemaRegistry, "SchemaRegistry");
+__publicField(_SchemaRegistry, "schemas", /* @__PURE__ */ new Map());
+var SchemaRegistry = _SchemaRegistry;
+function getSchemaDefaultValue(schema) {
+  const resolved = SchemaRegistry.resolve(schema);
+  switch (resolved.type) {
+    case "primitive":
+      if (resolved.defaultValue !== void 0) return resolved.defaultValue;
+      return getPrimitiveDefaultValue(resolved.primitive);
+    case "array":
+      if (resolved.defaultValue !== void 0) return [
+        ...resolved.defaultValue
+      ];
+      return [];
+    case "object": {
+      const obj = {};
+      for (const [key, propSchema] of Object.entries(resolved.properties)) {
+        obj[key] = getSchemaDefaultValue(propSchema);
+      }
+      return obj;
+    }
+    case "enum":
+      if (resolved.defaultValue !== void 0) return resolved.defaultValue;
+      return resolved.options[0]?.value;
+    default:
+      return void 0;
+  }
+}
+__name(getSchemaDefaultValue, "getSchemaDefaultValue");
+function getPrimitiveDefaultValue(primitive) {
+  switch (primitive) {
+    case "bool":
+      return false;
+    case "int":
+      return 0;
+    case "float":
+      return 0;
+    case "string":
+      return "";
+    case "vector2":
+      return {
+        x: 0,
+        y: 0
+      };
+    case "vector3":
+      return {
+        x: 0,
+        y: 0,
+        z: 0
+      };
+    case "color":
+      return {
+        r: 255,
+        g: 255,
+        b: 255,
+        a: 255
+      };
+    case "entity":
+      return null;
+    case "component":
+      return null;
+    case "object":
+      return null;
+    case "array":
+      return [];
+    case "any":
+      return null;
+    case "exec":
+      return void 0;
+    default:
+      return null;
+  }
+}
+__name(getPrimitiveDefaultValue, "getPrimitiveDefaultValue");
+function schemaToPinType(schema) {
+  const resolved = SchemaRegistry.resolve(schema);
+  switch (resolved.type) {
+    case "primitive":
+      return resolved.primitive;
+    case "array":
+      return "array";
+    case "object":
+      return "object";
+    case "enum":
+      return typeof resolved.options[0]?.value === "number" ? "int" : "string";
+    default:
+      return "any";
+  }
+}
+__name(schemaToPinType, "schemaToPinType");
+function validateSchema(schema, data, path = "") {
+  const resolved = SchemaRegistry.resolve(schema);
+  const errors = [];
+  switch (resolved.type) {
+    case "primitive":
+      validatePrimitive(resolved, data, path, errors);
+      break;
+    case "array":
+      validateArray(resolved, data, path, errors);
+      break;
+    case "object":
+      validateObject(resolved, data, path, errors);
+      break;
+    case "enum":
+      validateEnum(resolved, data, path, errors);
+      break;
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+__name(validateSchema, "validateSchema");
+function validatePrimitive(schema, data, path, errors) {
+  if (data === null || data === void 0) {
+    return;
+  }
+  const expectedType = getPrimitiveJsType(schema.primitive);
+  const actualType = typeof data;
+  if (expectedType === "object") {
+    if (typeof data !== "object") {
+      errors.push({
+        path,
+        message: `Expected ${schema.primitive}, got ${actualType}`,
+        expected: schema.primitive,
+        received: actualType
+      });
+    }
+  } else if (expectedType !== "any" && actualType !== expectedType) {
+    errors.push({
+      path,
+      message: `Expected ${expectedType}, got ${actualType}`,
+      expected: expectedType,
+      received: actualType
+    });
+  }
+  if ((schema.primitive === "int" || schema.primitive === "float") && typeof data === "number") {
+    if (schema.min !== void 0 && data < schema.min) {
+      errors.push({
+        path,
+        message: `Value ${data} is less than minimum ${schema.min}`
+      });
+    }
+    if (schema.max !== void 0 && data > schema.max) {
+      errors.push({
+        path,
+        message: `Value ${data} is greater than maximum ${schema.max}`
+      });
+    }
+  }
+}
+__name(validatePrimitive, "validatePrimitive");
+function validateArray(schema, data, path, errors) {
+  if (!Array.isArray(data)) {
+    errors.push({
+      path,
+      message: `Expected array, got ${typeof data}`,
+      expected: "array",
+      received: typeof data
+    });
+    return;
+  }
+  if (schema.minItems !== void 0 && data.length < schema.minItems) {
+    errors.push({
+      path,
+      message: `Array has ${data.length} items, minimum is ${schema.minItems}`
+    });
+  }
+  if (schema.maxItems !== void 0 && data.length > schema.maxItems) {
+    errors.push({
+      path,
+      message: `Array has ${data.length} items, maximum is ${schema.maxItems}`
+    });
+  }
+  for (let i = 0; i < data.length; i++) {
+    const itemResult = validateSchema(schema.items, data[i], `${path}[${i}]`);
+    errors.push(...itemResult.errors);
+  }
+}
+__name(validateArray, "validateArray");
+function validateObject(schema, data, path, errors) {
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    errors.push({
+      path,
+      message: `Expected object, got ${Array.isArray(data) ? "array" : typeof data}`,
+      expected: "object",
+      received: Array.isArray(data) ? "array" : typeof data
+    });
+    return;
+  }
+  const obj = data;
+  if (schema.required) {
+    for (const key of schema.required) {
+      if (!(key in obj)) {
+        errors.push({
+          path: path ? `${path}.${key}` : key,
+          message: `Missing required field: ${key}`
+        });
+      }
+    }
+  }
+  for (const [key, propSchema] of Object.entries(schema.properties)) {
+    if (key in obj) {
+      const propPath = path ? `${path}.${key}` : key;
+      const propResult = validateSchema(propSchema, obj[key], propPath);
+      errors.push(...propResult.errors);
+    }
+  }
+}
+__name(validateObject, "validateObject");
+function validateEnum(schema, data, path, errors) {
+  if (data === null || data === void 0) {
+    return;
+  }
+  const validValues = schema.options.map((o) => o.value);
+  if (!validValues.includes(data)) {
+    errors.push({
+      path,
+      message: `Invalid enum value: ${data}`,
+      expected: validValues.join(" | "),
+      received: String(data)
+    });
+  }
+}
+__name(validateEnum, "validateEnum");
+function getPrimitiveJsType(primitive) {
+  switch (primitive) {
+    case "bool":
+      return "boolean";
+    case "int":
+    case "float":
+      return "number";
+    case "string":
+      return "string";
+    case "vector2":
+    case "vector3":
+    case "color":
+    case "entity":
+    case "component":
+    case "object":
+    case "array":
+      return "object";
+    case "any":
+      return "any";
+    case "exec":
+      return "undefined";
+    default:
+      return "any";
+  }
+}
+__name(getPrimitiveJsType, "getPrimitiveJsType");
+function cloneSchema(schema) {
+  return JSON.parse(JSON.stringify(schema));
+}
+__name(cloneSchema, "cloneSchema");
+function mergeObjectSchemas(base, override) {
+  return {
+    ...base,
+    ...override,
+    properties: {
+      ...base.properties,
+      ...override.properties || {}
+    },
+    required: [
+      ...base.required || [],
+      ...override.required || []
+    ]
+  };
+}
+__name(mergeObjectSchemas, "mergeObjectSchemas");
+var Schema = {
+  // Primitives
+  bool(options) {
+    return {
+      type: "primitive",
+      primitive: "bool",
+      ...options
+    };
+  },
+  int(options) {
+    return {
+      type: "primitive",
+      primitive: "int",
+      ...options
+    };
+  },
+  float(options) {
+    return {
+      type: "primitive",
+      primitive: "float",
+      ...options
+    };
+  },
+  string(options) {
+    return {
+      type: "primitive",
+      primitive: "string",
+      ...options
+    };
+  },
+  vector2(options) {
+    return {
+      type: "primitive",
+      primitive: "vector2",
+      ...options
+    };
+  },
+  vector3(options) {
+    return {
+      type: "primitive",
+      primitive: "vector3",
+      ...options
+    };
+  },
+  color(options) {
+    return {
+      type: "primitive",
+      primitive: "color",
+      ...options
+    };
+  },
+  entity(options) {
+    return {
+      type: "primitive",
+      primitive: "entity",
+      ...options
+    };
+  },
+  component(options) {
+    return {
+      type: "primitive",
+      primitive: "component",
+      ...options
+    };
+  },
+  object_ref(options) {
+    return {
+      type: "primitive",
+      primitive: "object",
+      ...options
+    };
+  },
+  any(options) {
+    return {
+      type: "primitive",
+      primitive: "any",
+      ...options
+    };
+  },
+  // Complex types
+  array(items, options) {
+    return {
+      type: "array",
+      items,
+      ...options
+    };
+  },
+  object(properties, options) {
+    return {
+      type: "object",
+      properties,
+      ...options
+    };
+  },
+  enum(options, extra) {
+    return {
+      type: "enum",
+      options,
+      ...extra
+    };
+  },
+  ref(id) {
+    return {
+      type: "ref",
+      ref: id
+    };
+  }
+};
+
+// src/types/path-utils.ts
+function parsePath(path) {
+  const parts = [];
+  const regex = /([^.\[\]]+)|\[(\*|\d+)\]/g;
+  let match;
+  while ((match = regex.exec(path)) !== null) {
+    if (match[1]) {
+      parts.push({
+        type: "property",
+        name: match[1]
+      });
+    } else if (match[2] === "*") {
+      parts.push({
+        type: "wildcard"
+      });
+    } else {
+      parts.push({
+        type: "index",
+        index: parseInt(match[2], 10)
+      });
+    }
+  }
+  return parts;
+}
+__name(parsePath, "parsePath");
+function parsePortPath(path) {
+  const result = {
+    baseName: "",
+    indices: [],
+    subPath: [],
+    original: path
+  };
+  const parts = parsePath(path);
+  let foundFirstIndex = false;
+  let afterIndices = false;
+  for (const part of parts) {
+    if (part.type === "property") {
+      if (!foundFirstIndex) {
+        if (result.baseName) {
+          result.baseName += "." + part.name;
+        } else {
+          result.baseName = part.name;
+        }
+      } else {
+        afterIndices = true;
+        result.subPath.push(part.name);
+      }
+    } else if (part.type === "index") {
+      foundFirstIndex = true;
+      if (!afterIndices) {
+        result.indices.push(part.index);
+      } else {
+        result.subPath.push(`[${part.index}]`);
+      }
+    }
+  }
+  return result;
+}
+__name(parsePortPath, "parsePortPath");
+function buildPath(parts) {
+  let path = "";
+  for (const part of parts) {
+    switch (part.type) {
+      case "property":
+        if (path && !path.endsWith("[")) {
+          path += ".";
+        }
+        path += part.name;
+        break;
+      case "index":
+        path += `[${part.index}]`;
+        break;
+      case "wildcard":
+        path += "[*]";
+        break;
+    }
+  }
+  return path;
+}
+__name(buildPath, "buildPath");
+function buildPortPath(address) {
+  let path = address.baseName;
+  for (const index of address.indices) {
+    path += `[${index}]`;
+  }
+  if (address.subPath.length > 0) {
+    for (const sub of address.subPath) {
+      if (sub.startsWith("[")) {
+        path += sub;
+      } else {
+        path += "." + sub;
+      }
+    }
+  }
+  return path;
+}
+__name(buildPortPath, "buildPortPath");
+function getByPath(data, path) {
+  if (!path) return data;
+  const parts = parsePath(path);
+  let current = data;
+  for (const part of parts) {
+    if (current === null || current === void 0) {
+      return void 0;
+    }
+    switch (part.type) {
+      case "property":
+        if (typeof current === "object" && current !== null) {
+          current = current[part.name];
+        } else {
+          return void 0;
+        }
+        break;
+      case "index":
+        if (Array.isArray(current)) {
+          current = current[part.index];
+        } else {
+          return void 0;
+        }
+        break;
+      case "wildcard":
+        if (Array.isArray(current)) {
+          return current;
+        }
+        return void 0;
+    }
+  }
+  return current;
+}
+__name(getByPath, "getByPath");
+function setByPath(data, path, value) {
+  if (!path) return false;
+  const parts = parsePath(path);
+  let current = data;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (current === null || current === void 0) {
+      return false;
+    }
+    switch (part.type) {
+      case "property":
+        if (typeof current === "object" && current !== null) {
+          current = current[part.name];
+        } else {
+          return false;
+        }
+        break;
+      case "index":
+        if (Array.isArray(current)) {
+          current = current[part.index];
+        } else {
+          return false;
+        }
+        break;
+      case "wildcard":
+        return false;
+    }
+  }
+  const lastPart = parts[parts.length - 1];
+  if (current === null || current === void 0) {
+    return false;
+  }
+  switch (lastPart.type) {
+    case "property":
+      if (typeof current === "object" && current !== null) {
+        current[lastPart.name] = value;
+        return true;
+      }
+      break;
+    case "index":
+      if (Array.isArray(current)) {
+        current[lastPart.index] = value;
+        return true;
+      }
+      break;
+  }
+  return false;
+}
+__name(setByPath, "setByPath");
+function hasPath(data, path) {
+  return getByPath(data, path) !== void 0;
+}
+__name(hasPath, "hasPath");
+function deleteByPath(data, path) {
+  if (!path) return false;
+  const parts = parsePath(path);
+  let current = data;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (current === null || current === void 0) {
+      return false;
+    }
+    switch (part.type) {
+      case "property":
+        if (typeof current === "object" && current !== null) {
+          current = current[part.name];
+        } else {
+          return false;
+        }
+        break;
+      case "index":
+        if (Array.isArray(current)) {
+          current = current[part.index];
+        } else {
+          return false;
+        }
+        break;
+      default:
+        return false;
+    }
+  }
+  const lastPart = parts[parts.length - 1];
+  if (current === null || current === void 0) {
+    return false;
+  }
+  switch (lastPart.type) {
+    case "property":
+      if (typeof current === "object" && current !== null) {
+        delete current[lastPart.name];
+        return true;
+      }
+      break;
+    case "index":
+      if (Array.isArray(current)) {
+        current.splice(lastPart.index, 1);
+        return true;
+      }
+      break;
+  }
+  return false;
+}
+__name(deleteByPath, "deleteByPath");
+function updatePathOnArrayChange(path, arrayPath, operation, index, toIndex) {
+  if (!path.startsWith(arrayPath + "[")) {
+    return path;
+  }
+  const address = parsePortPath(path);
+  if (address.indices.length === 0) {
+    return path;
+  }
+  const currentIndex = address.indices[0];
+  switch (operation) {
+    case "insert":
+      if (currentIndex >= index) {
+        address.indices[0]++;
+      }
+      break;
+    case "remove":
+      if (currentIndex === index) {
+        return "";
+      }
+      if (currentIndex > index) {
+        address.indices[0]--;
+      }
+      break;
+    case "move":
+      if (toIndex !== void 0) {
+        if (currentIndex === index) {
+          address.indices[0] = toIndex;
+        } else if (index < toIndex) {
+          if (currentIndex > index && currentIndex <= toIndex) {
+            address.indices[0]--;
+          }
+        } else {
+          if (currentIndex >= toIndex && currentIndex < index) {
+            address.indices[0]++;
+          }
+        }
+      }
+      break;
+  }
+  return buildPortPath(address);
+}
+__name(updatePathOnArrayChange, "updatePathOnArrayChange");
+function expandWildcardPath(path, data) {
+  const parts = parsePath(path);
+  const results = [];
+  function expand(currentParts, currentData, index) {
+    if (index >= parts.length) {
+      results.push(buildPath(currentParts));
+      return;
+    }
+    const part = parts[index];
+    if (part.type === "wildcard") {
+      if (Array.isArray(currentData)) {
+        for (let i = 0; i < currentData.length; i++) {
+          const newParts = [
+            ...currentParts,
+            {
+              type: "index",
+              index: i
+            }
+          ];
+          expand(newParts, currentData[i], index + 1);
+        }
+      }
+    } else {
+      const newParts = [
+        ...currentParts,
+        part
+      ];
+      let nextData;
+      if (part.type === "property" && typeof currentData === "object" && currentData !== null) {
+        nextData = currentData[part.name];
+      } else if (part.type === "index" && Array.isArray(currentData)) {
+        nextData = currentData[part.index];
+      }
+      expand(newParts, nextData, index + 1);
+    }
+  }
+  __name(expand, "expand");
+  expand([], data, 0);
+  return results;
+}
+__name(expandWildcardPath, "expandWildcardPath");
+function hasWildcard(path) {
+  return path.includes("[*]");
+}
+__name(hasWildcard, "hasWildcard");
+function getParentPath(path) {
+  const parts = parsePath(path);
+  if (parts.length <= 1) {
+    return "";
+  }
+  return buildPath(parts.slice(0, -1));
+}
+__name(getParentPath, "getParentPath");
+function getPathLastName(path) {
+  const parts = parsePath(path);
+  if (parts.length === 0) {
+    return "";
+  }
+  const last = parts[parts.length - 1];
+  if (last.type === "property") {
+    return last.name;
+  } else if (last.type === "index") {
+    return `[${last.index}]`;
+  } else {
+    return "[*]";
+  }
+}
+__name(getPathLastName, "getPathLastName");
+
 // src/registry/BlueprintDecorators.ts
 var registeredComponents = /* @__PURE__ */ new Map();
 function getRegisteredBlueprintComponents() {
@@ -155,6 +933,67 @@ function BlueprintProperty(options = {}) {
   };
 }
 __name(BlueprintProperty, "BlueprintProperty");
+function BlueprintArray(options) {
+  return function(target, propertyKey) {
+    const key = String(propertyKey);
+    const metadata = getOrCreateMetadata(target.constructor);
+    const arraySchema = {
+      type: "array",
+      items: options.itemSchema,
+      defaultValue: options.defaultValue,
+      minItems: options.minItems,
+      maxItems: options.maxItems,
+      reorderable: options.reorderable,
+      collapsible: options.collapsible,
+      itemLabel: options.itemLabel
+    };
+    const propMeta = {
+      propertyKey: key,
+      displayName: options.displayName ?? key,
+      description: options.description,
+      pinType: "array",
+      readonly: false,
+      defaultValue: options.defaultValue,
+      schema: arraySchema,
+      isDynamicArray: true,
+      exposeElementPorts: options.exposeElementPorts,
+      portNameTemplate: options.portNameTemplate
+    };
+    const existingIndex = metadata.properties.findIndex((p) => p.propertyKey === key);
+    if (existingIndex >= 0) {
+      metadata.properties[existingIndex] = propMeta;
+    } else {
+      metadata.properties.push(propMeta);
+    }
+  };
+}
+__name(BlueprintArray, "BlueprintArray");
+function BlueprintObject(options) {
+  return function(target, propertyKey) {
+    const key = String(propertyKey);
+    const metadata = getOrCreateMetadata(target.constructor);
+    const objectSchema = {
+      type: "object",
+      properties: options.properties,
+      collapsible: options.collapsible
+    };
+    const propMeta = {
+      propertyKey: key,
+      displayName: options.displayName ?? key,
+      description: options.description,
+      pinType: "object",
+      readonly: false,
+      schema: objectSchema
+    };
+    const existingIndex = metadata.properties.findIndex((p) => p.propertyKey === key);
+    if (existingIndex >= 0) {
+      metadata.properties[existingIndex] = propMeta;
+    } else {
+      metadata.properties.push(propMeta);
+    }
+  };
+}
+__name(BlueprintObject, "BlueprintObject");
 function BlueprintMethod(options = {}) {
   return function(target, propertyKey, descriptor) {
     const key = String(propertyKey);
@@ -6149,6 +6988,548 @@ var SignExecutor = _SignExecutor;
 SignExecutor = _ts_decorate10([
   RegisterNode(SignTemplate)
 ], SignExecutor);
+var WrapTemplate = {
+  type: "Wrap",
+  title: "Wrap",
+  category: "math",
+  color: "#4CAF50",
+  description: "Wraps value to stay within min and max range (\u5C06\u503C\u5FAA\u73AF\u9650\u5236\u5728\u8303\u56F4\u5185)",
+  keywords: [
+    "wrap",
+    "loop",
+    "cycle",
+    "range",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0
+    },
+    {
+      name: "min",
+      type: "float",
+      displayName: "Min",
+      defaultValue: 0
+    },
+    {
+      name: "max",
+      type: "float",
+      displayName: "Max",
+      defaultValue: 1
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _WrapExecutor = class _WrapExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 0));
+    const min = Number(context.evaluateInput(node.id, "min", 0));
+    const max = Number(context.evaluateInput(node.id, "max", 1));
+    const range = max - min;
+    if (range <= 0) return {
+      outputs: {
+        result: min
+      }
+    };
+    const wrapped = ((value - min) % range + range) % range + min;
+    return {
+      outputs: {
+        result: wrapped
+      }
+    };
+  }
+};
+__name(_WrapExecutor, "WrapExecutor");
+var WrapExecutor = _WrapExecutor;
+WrapExecutor = _ts_decorate10([
+  RegisterNode(WrapTemplate)
+], WrapExecutor);
+var SinTemplate = {
+  type: "Sin",
+  title: "Sin",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the sine of angle in radians (\u8FD4\u56DE\u5F27\u5EA6\u89D2\u7684\u6B63\u5F26\u503C)",
+  keywords: [
+    "sin",
+    "sine",
+    "trig",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "radians",
+      type: "float",
+      displayName: "Radians",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _SinExecutor = class _SinExecutor {
+  execute(node, context) {
+    const radians = Number(context.evaluateInput(node.id, "radians", 0));
+    return {
+      outputs: {
+        result: Math.sin(radians)
+      }
+    };
+  }
+};
+__name(_SinExecutor, "SinExecutor");
+var SinExecutor = _SinExecutor;
+SinExecutor = _ts_decorate10([
+  RegisterNode(SinTemplate)
+], SinExecutor);
+var CosTemplate = {
+  type: "Cos",
+  title: "Cos",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the cosine of angle in radians (\u8FD4\u56DE\u5F27\u5EA6\u89D2\u7684\u4F59\u5F26\u503C)",
+  keywords: [
+    "cos",
+    "cosine",
+    "trig",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "radians",
+      type: "float",
+      displayName: "Radians",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _CosExecutor = class _CosExecutor {
+  execute(node, context) {
+    const radians = Number(context.evaluateInput(node.id, "radians", 0));
+    return {
+      outputs: {
+        result: Math.cos(radians)
+      }
+    };
+  }
+};
+__name(_CosExecutor, "CosExecutor");
+var CosExecutor = _CosExecutor;
+CosExecutor = _ts_decorate10([
+  RegisterNode(CosTemplate)
+], CosExecutor);
+var TanTemplate = {
+  type: "Tan",
+  title: "Tan",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the tangent of angle in radians (\u8FD4\u56DE\u5F27\u5EA6\u89D2\u7684\u6B63\u5207\u503C)",
+  keywords: [
+    "tan",
+    "tangent",
+    "trig",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "radians",
+      type: "float",
+      displayName: "Radians",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _TanExecutor = class _TanExecutor {
+  execute(node, context) {
+    const radians = Number(context.evaluateInput(node.id, "radians", 0));
+    return {
+      outputs: {
+        result: Math.tan(radians)
+      }
+    };
+  }
+};
+__name(_TanExecutor, "TanExecutor");
+var TanExecutor = _TanExecutor;
+TanExecutor = _ts_decorate10([
+  RegisterNode(TanTemplate)
+], TanExecutor);
+var AsinTemplate = {
+  type: "Asin",
+  title: "Asin",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the arc sine in radians (\u8FD4\u56DE\u53CD\u6B63\u5F26\u503C\uFF0C\u5355\u4F4D\u4E3A\u5F27\u5EA6)",
+  keywords: [
+    "asin",
+    "arc",
+    "sine",
+    "inverse",
+    "trig",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Radians"
+    }
+  ]
+};
+var _AsinExecutor = class _AsinExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 0));
+    return {
+      outputs: {
+        result: Math.asin(Math.max(-1, Math.min(1, value)))
+      }
+    };
+  }
+};
+__name(_AsinExecutor, "AsinExecutor");
+var AsinExecutor = _AsinExecutor;
+AsinExecutor = _ts_decorate10([
+  RegisterNode(AsinTemplate)
+], AsinExecutor);
+var AcosTemplate = {
+  type: "Acos",
+  title: "Acos",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the arc cosine in radians (\u8FD4\u56DE\u53CD\u4F59\u5F26\u503C\uFF0C\u5355\u4F4D\u4E3A\u5F27\u5EA6)",
+  keywords: [
+    "acos",
+    "arc",
+    "cosine",
+    "inverse",
+    "trig",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Radians"
+    }
+  ]
+};
+var _AcosExecutor = class _AcosExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 0));
+    return {
+      outputs: {
+        result: Math.acos(Math.max(-1, Math.min(1, value)))
+      }
+    };
+  }
+};
+__name(_AcosExecutor, "AcosExecutor");
+var AcosExecutor = _AcosExecutor;
+AcosExecutor = _ts_decorate10([
+  RegisterNode(AcosTemplate)
+], AcosExecutor);
+var AtanTemplate = {
+  type: "Atan",
+  title: "Atan",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the arc tangent in radians (\u8FD4\u56DE\u53CD\u6B63\u5207\u503C\uFF0C\u5355\u4F4D\u4E3A\u5F27\u5EA6)",
+  keywords: [
+    "atan",
+    "arc",
+    "tangent",
+    "inverse",
+    "trig",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Radians"
+    }
+  ]
+};
+var _AtanExecutor = class _AtanExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 0));
+    return {
+      outputs: {
+        result: Math.atan(value)
+      }
+    };
+  }
+};
+__name(_AtanExecutor, "AtanExecutor");
+var AtanExecutor = _AtanExecutor;
+AtanExecutor = _ts_decorate10([
+  RegisterNode(AtanTemplate)
+], AtanExecutor);
+var Atan2Template = {
+  type: "Atan2",
+  title: "Atan2",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the angle in radians between the positive X axis and the point (x, y) (\u8FD4\u56DE\u70B9(x,y)\u4E0E\u6B63X\u8F74\u4E4B\u95F4\u7684\u5F27\u5EA6\u89D2)",
+  keywords: [
+    "atan2",
+    "angle",
+    "direction",
+    "trig",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "y",
+      type: "float",
+      displayName: "Y",
+      defaultValue: 0
+    },
+    {
+      name: "x",
+      type: "float",
+      displayName: "X",
+      defaultValue: 1
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Radians"
+    }
+  ]
+};
+var _Atan2Executor = class _Atan2Executor {
+  execute(node, context) {
+    const y = Number(context.evaluateInput(node.id, "y", 0));
+    const x = Number(context.evaluateInput(node.id, "x", 1));
+    return {
+      outputs: {
+        result: Math.atan2(y, x)
+      }
+    };
+  }
+};
+__name(_Atan2Executor, "Atan2Executor");
+var Atan2Executor = _Atan2Executor;
+Atan2Executor = _ts_decorate10([
+  RegisterNode(Atan2Template)
+], Atan2Executor);
+var DegToRadTemplate = {
+  type: "DegToRad",
+  title: "Degrees to Radians",
+  category: "math",
+  color: "#4CAF50",
+  description: "Converts degrees to radians (\u5C06\u89D2\u5EA6\u8F6C\u6362\u4E3A\u5F27\u5EA6)",
+  keywords: [
+    "degrees",
+    "radians",
+    "convert",
+    "angle",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "degrees",
+      type: "float",
+      displayName: "Degrees",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Radians"
+    }
+  ]
+};
+var _DegToRadExecutor = class _DegToRadExecutor {
+  execute(node, context) {
+    const degrees = Number(context.evaluateInput(node.id, "degrees", 0));
+    return {
+      outputs: {
+        result: degrees * (Math.PI / 180)
+      }
+    };
+  }
+};
+__name(_DegToRadExecutor, "DegToRadExecutor");
+var DegToRadExecutor = _DegToRadExecutor;
+DegToRadExecutor = _ts_decorate10([
+  RegisterNode(DegToRadTemplate)
+], DegToRadExecutor);
+var RadToDegTemplate = {
+  type: "RadToDeg",
+  title: "Radians to Degrees",
+  category: "math",
+  color: "#4CAF50",
+  description: "Converts radians to degrees (\u5C06\u5F27\u5EA6\u8F6C\u6362\u4E3A\u89D2\u5EA6)",
+  keywords: [
+    "radians",
+    "degrees",
+    "convert",
+    "angle",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "radians",
+      type: "float",
+      displayName: "Radians",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Degrees"
+    }
+  ]
+};
+var _RadToDegExecutor = class _RadToDegExecutor {
+  execute(node, context) {
+    const radians = Number(context.evaluateInput(node.id, "radians", 0));
+    return {
+      outputs: {
+        result: radians * (180 / Math.PI)
+      }
+    };
+  }
+};
+__name(_RadToDegExecutor, "RadToDegExecutor");
+var RadToDegExecutor = _RadToDegExecutor;
+RadToDegExecutor = _ts_decorate10([
+  RegisterNode(RadToDegTemplate)
+], RadToDegExecutor);
+var InverseLerpTemplate = {
+  type: "InverseLerp",
+  title: "Inverse Lerp",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the percentage of Value between A and B (\u8FD4\u56DE\u503C\u5728 A \u548C B \u4E4B\u95F4\u7684\u767E\u5206\u6BD4\u4F4D\u7F6E)",
+  keywords: [
+    "inverse",
+    "lerp",
+    "percentage",
+    "ratio",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "float",
+      displayName: "A",
+      defaultValue: 0
+    },
+    {
+      name: "b",
+      type: "float",
+      displayName: "B",
+      defaultValue: 1
+    },
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0.5
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Alpha (0-1)"
+    }
+  ]
+};
+var _InverseLerpExecutor = class _InverseLerpExecutor {
+  execute(node, context) {
+    const a = Number(context.evaluateInput(node.id, "a", 0));
+    const b = Number(context.evaluateInput(node.id, "b", 1));
+    const value = Number(context.evaluateInput(node.id, "value", 0.5));
+    if (b === a) return {
+      outputs: {
+        result: 0
+      }
+    };
+    return {
+      outputs: {
+        result: (value - a) / (b - a)
+      }
+    };
+  }
+};
+__name(_InverseLerpExecutor, "InverseLerpExecutor");
+var InverseLerpExecutor = _InverseLerpExecutor;
+InverseLerpExecutor = _ts_decorate10([
+  RegisterNode(InverseLerpTemplate)
+], InverseLerpExecutor);
 
 // src/nodes/logic/ComparisonNodes.ts
 function _ts_decorate11(decorators, target, key, desc) {
@@ -7123,11 +8504,13 @@ __name(registerComponentClass, "registerComponentClass");
 export {
   AlwaysFalseCondition,
   AlwaysTrueCondition,
+  BlueprintArray,
   BlueprintComponent,
   BlueprintComposer,
   BlueprintExpose,
   BlueprintFragment,
   BlueprintMethod,
+  BlueprintObject,
   BlueprintProperty,
   BlueprintSystem,
   BlueprintTrigger,
@@ -7146,6 +8529,8 @@ export {
   NodeRegistry,
   NotCondition,
   RegisterNode,
+  Schema,
+  SchemaRegistry,
   StateNameCondition,
   TimerIdCondition,
   TriggerDispatcher,
@@ -7153,7 +8538,10 @@ export {
   TriggerTypeCondition,
   TriggerTypes,
   arePinTypesCompatible,
+  buildPath,
+  buildPortPath,
   clearRegisteredComponents,
+  cloneSchema,
   condition,
   createCollisionContext,
   createCollisionTrigger,
@@ -7179,17 +8567,33 @@ export {
   createTrigger,
   createTriggerDispatcher,
   defaultFragmentRegistry,
+  deleteByPath,
+  expandWildcardPath,
   fragmentFromAsset,
   fragmentToAsset,
   generateComponentNodes,
   getBlueprintMetadata,
+  getByPath,
   getNodeCategoryColor,
+  getParentPath,
+  getPathLastName,
   getPinTypeColor,
+  getPrimitiveDefaultValue,
   getRegisteredBlueprintComponents,
+  getSchemaDefaultValue,
+  hasPath,
+  hasWildcard,
   inferPinType,
+  mergeObjectSchemas,
+  parsePath,
+  parsePortPath,
   registerAllComponentNodes,
   registerComponentClass,
   registerComponentNodes,
-  validateBlueprintAsset
+  schemaToPinType,
+  setByPath,
+  updatePathOnArrayChange,
+  validateBlueprintAsset,
+  validateSchema
 };
 //# sourceMappingURL=index.js.map