pacc 9.2.13 → 9.3.0

package/README.md

@@ -831,6 +831,9 @@ Type: [Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Globa
 
 *   `name` **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** 
 *   `primitive` **[boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** 
+*   `extends` **[Type](#type)?** 
+*   `members` **[Set](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Set)<[Type](#type)>?**&#x20;
+*   `clazz` **[Function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)?**&#x20;
 *   `toInternal` **[Function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)?**&#x20;
 *   `toExternal` **[Function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)?**&#x20;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pacc",
-  "version": "9.2.13",
+  "version": "9.3.0",
   "publishConfig": {
     "access": "public",
     "provenance": true
@@ -43,13 +43,13 @@
   },
   "devDependencies": {
     "@mitata/counters": "^0.0.8",
-    "aggregated-map": "^1.0.3",
+    "aggregated-map": "^1.0.4",
     "ava": "^8.0.1",
     "browser-ava": "^2.3.61",
     "c8": "^11.0.0",
     "documentation": "^14.0.3",
     "mitata": "^1.0.34",
-    "semantic-release": "^25.0.3",
+    "semantic-release": "^25.0.5",
     "typescript": "^6.0.3"
   },
   "overrides": {

package/src/attributes.mjs

@@ -45,17 +45,17 @@ function mergeAttributeDefinitions(dest, atts) {
 }
 
 /**
- * Iterate over all attributes.
- * @param {Object} definition
+ * Iterate over attributes.
+ * @param {Object} attribute definition
  * @param {Function} [filter]
- * @param {string[]} path
+ * @param {string[]} [path]
  * @return {Iterable<[string[],object]>}
  */
 export function* attributeIterator(definition, filter, path = []) {
   if (definition) {
     for (const [name, def] of Object.entries(definition)) {
       const path2 = [...path, name];
-      if (typeof filter !== 'function' || filter(name, def)) {
+      if (typeof filter !== "function" || filter(name, def)) {
         yield [path2, def];
       }
 
@@ -64,6 +64,20 @@ export function* attributeIterator(definition, filter, path = []) {
   }
 }
 
+/**
+ * Iterate over all attributes of a type.
+ * @param {Type} type definition
+ * @param {Function} [filter]
+ * @param {string[]} [path]
+ * @return {Iterable<[string[],object]>}
+ */
+export function* extendingAttributeIterator(type, filter, path) {
+  if (type.extends) {
+    yield* extendingAttributeIterator(type.extends, filter, path);
+  }
+  yield* attributeIterator(type.attributes, filter, path);
+}
+
 export const filterWritable = (name, attribute) => attribute.writable;
 export const filterPublic = (name, attribute) => !attribute.private;
 

package/src/common-attributes.mjs

@@ -5,6 +5,7 @@ import { types } from "./types.mjs";
  *
  * @property {object} type
  * @property {boolean} isKey
+ * @property {boolean} isOwner are we the owner of the value
  * @property {boolean} writable
  * @property {boolean} mandatory
  * @property {boolean} collection
@@ -19,11 +20,11 @@ import { types } from "./types.mjs";
  * @property {Function} [get] get the value can be used to calculate default values
  * @property {Function} [toInternal]
  * @property {Function} [toExternal]
- * @property {Set<any>} [values] allowed values
  * @property {string} [externalName] attribute name used by external system
+ * @property {Set<any>} [values] allowed values
  * @property {string[]|string} [env] environment variable(s) used to provide the value
  * @property {object} [additionalValues] other values to be set in case our attribute is set
- * @property {string} [separator]  separator for collections
+ * @property {string} [separator] separator for collections
  */
 
 /**
@@ -38,7 +39,8 @@ export const default_attribute = {
   persistent: false,
   private: false,
   credential: false,
-  isKey: false
+  isKey: false,
+  isOwner: true
 };
 
 /**

package/src/types.mjs

@@ -6,6 +6,9 @@ import { parseBytes } from "./bytes.mjs";
  * @typedef {Object} Type
  * @property {string} name
  * @property {boolean} [primitive]
+ * @property {Type} [extends]
+ * @property {Set<Type>} [members]
+ * @property {Function} [clazz]
  * @property {Function} [toInternal]
  * @property {Function} [toExternal]
  */
@@ -121,28 +124,11 @@ function raiseOnUnknownType(type, origin) {
 }
 
 export function addType(type) {
-  if (type.typeDefinition) {
-    const clazz = type;
-    type = type.typeDefinition;
-    type.clazz = clazz;
-  } else {
-    if (!!type?.constructor.name) {
-      const clazz = type;
-      type.clazz = clazz;
-    }
-  }
-
-  if (type.specializationOf) {
-    type.specializationOf.specializations[type.name] = type;
-  }
-
-  type.owners ||= [];
-
   switch (typeof type.extends) {
     case "undefined":
-      const ex = Object.getPrototypeOf(type.clazz);
+      const ex = Object.getPrototypeOf(type.clazz || type);
       if (ex?.name) {
-        type.extends = ex.typeDefinition || ex;
+        type.extends = ex;
       }
       break;
 
@@ -151,14 +137,19 @@ export function addType(type) {
       break;
   }
 
-  if (!types[type.name]) {
-    types[type.name] = type;
+  if (type.specializationOf) {
+    type.specializationOf.specializations[type.name] = type;
   }
 
-  if (types[type.name] !== type) {
-    return Object.assign(types[type.name], type);
-  }
+  type.owners ||= [];
 
+  if (!types[type.name]) {
+    types[type.name] = type;
+  } else {
+    if (types[type.name] !== type) {
+      return Object.assign(types[type.name], type);
+    }
+  }
   return type;
 }
 
@@ -213,7 +204,7 @@ export function resolveTypeLinks() {
 }
 
 export function typeFactory(type, owner, data) {
-  const factory = type.factoryFor?.(owner, data) || type.clazz;
+  const factory = type.factoryFor?.(owner, data) || type.clazz || type;
   const object = new factory(owner);
 
   object.read(data);

package/types/attributes.d.mts

@@ -6,13 +6,21 @@
  */
 export function prepareAttributesDefinitions(newDefinitions: Object, presentDefinitions?: Object): Object;
 /**
- * Iterate over all attributes.
- * @param {Object} definition
+ * Iterate over attributes.
+ * @param {Object} attribute definition
  * @param {Function} [filter]
- * @param {string[]} path
+ * @param {string[]} [path]
  * @return {Iterable<[string[],object]>}
  */
-export function attributeIterator(definition: Object, filter?: Function, path?: string[]): Iterable<[string[], object]>;
+export function attributeIterator(definition: any, filter?: Function, path?: string[]): Iterable<[string[], object]>;
+/**
+ * Iterate over all attributes of a type.
+ * @param {Type} type definition
+ * @param {Function} [filter]
+ * @param {string[]} [path]
+ * @return {Iterable<[string[],object]>}
+ */
+export function extendingAttributeIterator(type: Type, filter?: Function, path?: string[]): Iterable<[string[], object]>;
 export function writableAttributeIterator(definition: any): Generator<[string[], object], void, any>;
 export function toInternal(value: any, attribute: any): any;
 export function toExternal(value: any, attribute: any): any;

package/types/common-attributes.d.mts

@@ -3,6 +3,7 @@
  *
  * @property {object} type
  * @property {boolean} isKey
+ * @property {boolean} isOwner are we the owner of the value
  * @property {boolean} writable
  * @property {boolean} mandatory
  * @property {boolean} collection
@@ -17,11 +18,11 @@
  * @property {Function} [get] get the value can be used to calculate default values
  * @property {Function} [toInternal]
  * @property {Function} [toExternal]
- * @property {Set<any>} [values] allowed values
  * @property {string} [externalName] attribute name used by external system
+ * @property {Set<any>} [values] allowed values
  * @property {string[]|string} [env] environment variable(s) used to provide the value
  * @property {object} [additionalValues] other values to be set in case our attribute is set
- * @property {string} [separator]  separator for collections
+ * @property {string} [separator] separator for collections
  */
 /**
  * Common attribute properties.
@@ -101,6 +102,7 @@ export namespace yesno_attribute_writable {
     export let writable: boolean;
     export let type: object;
     export let isKey: boolean;
+    export let isOwner: boolean;
     export let mandatory: boolean;
     export let collection: boolean;
     export let constructor: Function | undefined;
@@ -116,8 +118,8 @@ export namespace yesno_attribute_writable {
     export let get: Function | undefined;
     export let toInternal: Function | undefined;
     export let toExternal: Function | undefined;
-    export let values: Set<any> | undefined;
     export let externalName: string | undefined;
+    export let values: Set<any> | undefined;
     export let env: string | string[] | undefined;
     export let additionalValues: object | undefined;
     export let separator: string | undefined;
@@ -228,6 +230,10 @@ export const language_attribute: AttributeDefinition;
 export type AttributeDefinition = {
     type: object;
     isKey: boolean;
+    /**
+     * are we the owner of the value
+     */
+    isOwner: boolean;
     writable: boolean;
     mandatory: boolean;
     collection: boolean;
@@ -269,14 +275,14 @@ export type AttributeDefinition = {
     get?: Function | undefined;
     toInternal?: Function | undefined;
     toExternal?: Function | undefined;
-    /**
-     * allowed values
-     */
-    values?: Set<any> | undefined;
     /**
      * attribute name used by external system
      */
     externalName?: string | undefined;
+    /**
+     * allowed values
+     */
+    values?: Set<any> | undefined;
     /**
      * environment variable(s) used to provide the value
      */

package/types/types.d.mts

@@ -64,6 +64,9 @@ export const types: {
 export type Type = {
     name: string;
     primitive?: boolean | undefined;
+    extends?: Type | undefined;
+    members?: Set<Type> | undefined;
+    clazz?: Function | undefined;
     toInternal?: Function | undefined;
     toExternal?: Function | undefined;
 };