pacc 4.36.0 → 4.37.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pacc",
-  "version": "4.36.0",
+  "version": "4.37.1",
   "publishConfig": {
     "access": "public",
     "provenance": true

package/src/types.mjs

@@ -1,18 +1,16 @@
-export const baseTypes = new Set(["string", "number", "bigint", "boolean"]);
+import { attributeIterator } from "./attributes.mjs";
 
 export const types = {
-  base: { name: "base" },
-
-  string: { name: "string", extends: "base" },
+  string: { name: "string", primitive: true },
   number: {
     name: "number",
-    extends: "base",
+    primitive: true,
     prepareValue: value =>
       typeof value === "string" ? parseFloat(value) : value
   },
   boolean: {
     name: "boolean",
-    extends: "base",
+    primitive: true,
     prepareValue: value =>
       !value || value === "0" || value === "false" || value === "no"
         ? false
@@ -20,53 +18,73 @@ export const types = {
   },
   integer: {
     name: "integer",
-    extends: "base",
+    primitive: true,
     prepareValue: value => (typeof value === "string" ? parseInt(value) : value)
   },
   "unsigned-integer": {
     name: "unsigned-integer",
-    prepareValue: value =>
-      typeof value === "string" ? parseInt(value) : value,
-    extends: "integer"
+    primitive: true,
+    prepareValue: value => (typeof value === "string" ? parseInt(value) : value)
   },
-  url: { name: "url", extends: "string" },
+  url: { name: "url", primitive: true },
   object: { name: "object", extends: "base" }
 };
 
+function error(message) {
+  throw new Error(message);
+}
+
 export function addType(type) {
+  if (types[type.name]) {
+    return Object.assign(types[type.name], type);
+  }
+
   types[type.name] = type;
+
+  for (const [path, attribute] of attributeIterator(type.attributes)) {
+    if (typeof attribute.type === "string") {
+      attribute.type = oneOfType(attribute.type);
+    }
+    if(attribute.isKey && !type.key) {
+      type.key = path.join('.');
+    }
+  }
+
   return type;
 }
 
 export function oneOfType(definition) {
-  const aggregate = list =>
-    list.reduce(
-      (a, c) => a.union(c?.members ?? new Set([types[c] ?? c])),
-      new Set()
-    );
+  const aggregate = (name, list) => {
+    const def = {
+      name,
+      members: list.reduce((all, type) => {
+        if (typeof type === "string") {
+          const t = types[type] || addType({ name: type });
+          if (!t) {
+            error(`Unknown type ${type} in '${definition}'`);
+          }
+          type = t;
+        }
+        return all.union(type.members ?? new Set([type]));
+      }, new Set())
+    };
 
-  if (Array.isArray(definition)) {
-    const name = definition
-      .map(t => t.name ?? t)
-      .sort()
-      .join("|");
+    if (def.members.size < 2) {
+      delete def.members;
+    }
+    return types[name] || addType(def);
+  };
 
-    return (
-      types[name] ||
-      addType({
-        name,
-        members: aggregate(definition)
-      })
+  if (Array.isArray(definition)) {
+    return aggregate(
+      definition
+        .map(t => t.name ?? t)
+        .sort()
+        .join("|"),
+      definition
     );
   } else {
     const parts = definition.split("|").sort();
-    const name = parts.join("|");
-    return (
-      types[name] ||
-      addType({
-        name,
-        members: aggregate(parts.map(t => types[t]))
-      })
-    );
+    return aggregate(parts.join("|"), parts);
   }
 }

package/types/types.d.mts

@@ -1,37 +1,33 @@
 export function addType(type: any): any;
 export function oneOfType(definition: any): any;
-export const baseTypes: Set<string>;
 export const types: {
-    base: {
-        name: string;
-    };
     string: {
         name: string;
-        extends: string;
+        primitive: boolean;
     };
     number: {
         name: string;
-        extends: string;
+        primitive: boolean;
         prepareValue: (value: any) => any;
     };
     boolean: {
         name: string;
-        extends: string;
+        primitive: boolean;
         prepareValue: (value: any) => boolean;
     };
     integer: {
         name: string;
-        extends: string;
+        primitive: boolean;
         prepareValue: (value: any) => any;
     };
     "unsigned-integer": {
         name: string;
+        primitive: boolean;
         prepareValue: (value: any) => any;
-        extends: string;
     };
     url: {
         name: string;
-        extends: string;
+        primitive: boolean;
     };
     object: {
         name: string;