@forgeax/engine-pack 0.1.3 → 0.1.6

package/dist/index.mjs

@@ -7448,6 +7448,22 @@ var SCRIPTABLE_PACK_ASSET_KINDS = [
 function isScriptablePackAssetKind(value) {
   return SCRIPTABLE_PACK_ASSET_KINDS.includes(value);
 }
+function sceneComponentFieldType(value) {
+  if (typeof value === "string") return value;
+  if (isRecord2(value) && typeof value.type === "string") return value.type;
+  return void 0;
+}
+function projectScriptablePackSceneComponents(components) {
+  return (components ?? []).map((component) => ({
+    name: component.name,
+    fields: Object.fromEntries(
+      Object.entries(component.fields).map(([fieldName, field]) => [
+        fieldName,
+        sceneComponentFieldType(field)
+      ])
+    )
+  }));
+}
 var SCRIPTABLE_PACK_REQUEST_ID_SCHEMA = {
   type: "string",
   minLength: 1,
@@ -7673,11 +7689,20 @@ function freezeDefinition(definition) {
       guid.slice()
     ])
   );
+  const sceneComponents = definition.sceneComponents === void 0 ? void 0 : Object.freeze(
+    projectScriptablePackSceneComponents(definition.sceneComponents).map(
+      (component) => Object.freeze({
+        ...component,
+        fields: Object.freeze({ ...component.fields })
+      })
+    )
+  );
   return Object.freeze({
     ...definition,
     packageId: definition.packageId.slice(),
     assets: Object.freeze(assets),
-    externalAssets: Object.freeze(externalAssets)
+    externalAssets: Object.freeze(externalAssets),
+    ...sceneComponents === void 0 ? {} : { sceneComponents }
   });
 }
 function validateScriptablePackDefinition(value, sourcePath) {
@@ -7708,6 +7733,63 @@ function validateScriptablePackDefinition(value, sourcePath) {
       sourcePath
     );
   }
+  if (value.sceneComponents !== void 0) {
+    if (!Array.isArray(value.sceneComponents)) {
+      return invalid2(
+        "$.sceneComponents",
+        "an array of component tokens or neutral schema rows when present",
+        value.sceneComponents,
+        sourcePath
+      );
+    }
+    const componentNames = /* @__PURE__ */ new Set();
+    for (const [componentIndex, component] of value.sceneComponents.entries()) {
+      if (!isRecord2(component)) {
+        return invalid2(
+          `$.sceneComponents[${componentIndex}]`,
+          "a component token or neutral schema row",
+          component,
+          sourcePath
+        );
+      }
+      if (typeof component.name !== "string" || component.name.trim().length === 0) {
+        return invalid2(
+          `$.sceneComponents[${componentIndex}].name`,
+          "a non-empty component name",
+          component.name,
+          sourcePath
+        );
+      }
+      if (componentNames.has(component.name)) {
+        return invalid2(
+          `$.sceneComponents[${componentIndex}].name`,
+          "component names to be unique within one ScriptablePack",
+          component.name,
+          sourcePath
+        );
+      }
+      componentNames.add(component.name);
+      if (!isRecord2(component.fields)) {
+        return invalid2(
+          `$.sceneComponents[${componentIndex}].fields`,
+          "a field-name to schema-type object",
+          component.fields,
+          sourcePath
+        );
+      }
+      for (const [fieldName, field] of Object.entries(component.fields)) {
+        const type = sceneComponentFieldType(field);
+        if (fieldName.trim().length === 0 || type === void 0 || type.trim().length === 0) {
+          return invalid2(
+            `$.sceneComponents[${componentIndex}].fields`,
+            "field names with non-empty string schema types",
+            field,
+            sourcePath
+          );
+        }
+      }
+    }
+  }
   if (typeof value.build !== "function") {
     return invalid2("$.build", "a build(assetReader) function", value.build, sourcePath);
   }