pmcf 3.9.1 → 3.9.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmcf",
-  "version": "3.9.1",
+  "version": "3.9.3",
   "publishConfig": {
     "access": "public"
   },
@@ -51,13 +51,13 @@
     "lint:typescript": "tsc --allowJs --checkJs --noEmit --resolveJsonModule --target esnext -m esnext --module nodenext --moduleResolution nodenext ./src**/*.mjs"
   },
   "dependencies": {
-    "ip-utilties": "^1.4.8",
+    "ip-utilties": "^1.4.9",
     "npm-pkgbuild": "^18.2.30",
-    "pacc": "^4.15.1",
+    "pacc": "^4.16.0",
     "package-directory": "^8.1.0"
   },
   "devDependencies": {
-    "@types/node": "^24.3.2",
+    "@types/node": "^24.3.3",
     "ava": "^6.4.1",
     "c8": "^10.1.3",
     "documentation": "^14.0.3",

package/src/base.mjs

@@ -2,6 +2,7 @@ import { join } from "node:path";
 import { allOutputs } from "npm-pkgbuild";
 import {
   getAttribute,
+  baseTypes,
   name_attribute_writable,
   string_attribute,
   string_attribute_writable,
@@ -10,7 +11,7 @@ import {
   description_attribute,
   boolean_attribute_writable
 } from "pacc";
-import { addType, primitives, typeFactory } from "./types.mjs";
+import { addType, typeFactory } from "./types.mjs";
 import { asArray } from "./utils.mjs";
 
 const BaseTypeDefinition = {
@@ -90,24 +91,22 @@ export class Base {
     return this;
   }
 
-  read(data, type=this.constructor.typeDefinition) {
-    if(type.extends) {
+  read(data, type = this.constructor.typeDefinition) {
+    if (type.extends) {
       this.read(data, type.extends);
     }
 
-    const assign = (name, property, value) => {
-      if (value === undefined && property.default !== undefined) {
-        value = property.default;
-      }
+    const assign = (name, attribute, value) => {
+      value ??= attribute.default;
 
       if (value !== undefined) {
-        if (property.values) {
-          if (property.values.indexOf(value) < 0) {
-            this.error(name, "unknown value", value, property.values);
+        if (attribute.values) {
+          if (attribute.values.indexOf(value) < 0) {
+            this.error(name, "unknown value", value, attribute.values);
           }
         }
 
-        if (property.collection) {
+        if (attribute.collection) {
           const current = this[name];
 
           switch (typeof current) {
@@ -143,9 +142,9 @@ export class Base {
       }
     };
 
-    const instantiateAndAssign = (name, property, value) => {
-      if (primitives.has(property.type[0])) {
-        assign(name, property, value);
+    const instantiateAndAssign = (name, attribute, value) => {
+      if (baseTypes.has(attribute.type[0])) {
+        assign(name, attribute, value);
         return;
       }
 
@@ -163,7 +162,7 @@ export class Base {
           {
             let object;
 
-            for (const type of property.type) {
+            for (const type of attribute.type) {
               object = this.typeNamed(type.name, value);
               if (object) {
                 break;
@@ -171,11 +170,11 @@ export class Base {
             }
 
             if (object) {
-              assign(name, property, object);
+              assign(name, attribute, object);
             } else {
-              if (property.type[0].constructWithIdentifierOnly) {
-                object = new property.type[0].clazz(
-                  this.ownerFor(property, value),
+              if (attribute.type[0].constructWithIdentifierOnly) {
+                object = new attribute.type[0].clazz(
+                  this.ownerFor(attribute, value),
                   value
                 );
                 object.read(value);
@@ -184,14 +183,14 @@ export class Base {
                 this.finalize(() => {
                   value = this.expand(value);
 
-                  for (const type of property.type) {
+                  for (const type of attribute.type) {
                     const object =
                       this.typeNamed(type.name, value) ||
                       this.owner.typeNamed(type.name, value) ||
                       this.root.typeNamed(type.name, value); // TODO
 
                     if (object) {
-                      assign(name, property, object);
+                      assign(name, attribute, object);
                       return;
                     }
                   }
@@ -199,7 +198,7 @@ export class Base {
                   this.error(
                     "Not found",
                     name,
-                    property.type.map(t => t.name),
+                    attribute.type.map(t => t.name),
                     value
                   );
                 });
@@ -208,15 +207,15 @@ export class Base {
           }
           break;
         case "object":
-          if (value instanceof property.type[0].clazz) {
-            assign(name, property, value);
+          if (value instanceof attribute.type[0].clazz) {
+            assign(name, attribute, value);
           } else {
             assign(
               name,
-              property,
+              attribute,
               typeFactory(
-                property.type[0],
-                this.ownerFor(property, value),
+                attribute.type[0],
+                this.ownerFor(attribute, value),
                 value
               )
             );
@@ -229,32 +228,32 @@ export class Base {
       this._properties = data.properties;
     }
 
-    for (const [name, property] of Object.entries(type.properties)) {
-      if (property.writable) {
+    for (const [name, attribute] of Object.entries(type.properties)) {
+      if (attribute.writable) {
         const value = this.expand(data[name]);
 
-        if (property.collection) {
+        if (attribute.collection) {
           if (typeof value === "object") {
             if (Array.isArray(value)) {
               for (const v of value) {
-                instantiateAndAssign(name, property, v);
+                instantiateAndAssign(name, attribute, v);
               }
             } else {
               if (value instanceof Base) {
-                assign(name, property, value);
+                assign(name, attribute, value);
               } else {
                 for (const [objectName, objectData] of Object.entries(value)) {
                   if (typeof objectData === "object") {
                     objectData[type.identifier.name] = objectName;
                   }
-                  instantiateAndAssign(name, property, objectData);
+                  instantiateAndAssign(name, attribute, objectData);
                 }
               }
             }
             continue;
           }
         }
-        instantiateAndAssign(name, property, value);
+        instantiateAndAssign(name, attribute, value);
       }
     }
   }

package/src/services/bind.mjs

@@ -4,10 +4,10 @@ import { FileContentProvider } from "npm-pkgbuild";
 import { isLinkLocal, reverseArpa } from "ip-utilties";
 import {
   string_attribute_writable,
-  string_collection_attribute,
   boolean_attribute_writable_true,
   boolean_attribute_writable_false,
-  number_attribute
+  number_attribute,
+  string_collection_attribute_writable
 } from "pacc";
 import { writeLines, asArray } from "../utils.mjs";
 import {
@@ -48,8 +48,7 @@ const BindServiceTypeDefinition = {
     hasLinkLocalAdresses: boolean_attribute_writable_false,
     hasLocationRecord: boolean_attribute_writable_true,
     excludeInterfaceKinds: {
-      ...string_collection_attribute,
-      writable: true
+      ...string_collection_attribute_writable
     },
     exclude: { type: address_types, collection: true, writable: true },
     notify: boolean_attribute_writable_false,
@@ -59,7 +58,7 @@ const BindServiceTypeDefinition = {
     retry: { ...string_attribute_writable, default: 72000 },
     expire: { ...string_attribute_writable, default: 600000 },
     minimum: { ...string_attribute_writable, default: 60000 },
-    allowedUpdates: { ...string_collection_attribute, writable: true }
+    allowedUpdates: { ...string_collection_attribute_writable }
   },
 
   service: {

package/src/types.mjs

@@ -1,3 +1,4 @@
+import { baseTypes } from "pacc";
 import { asArray } from "./utils.mjs";
 import { addServiceTypes } from "./service-types.mjs";
 
@@ -19,8 +20,6 @@ export function addType(clazz) {
   type.clazz = clazz;
 }
 
-export const primitives = new Set(["string", "number", "boolean"]);
-
 export function resolveTypeLinks() {
   for (const type of Object.values(types)) {
     type.owners = type.owners.map(owner =>
@@ -37,7 +36,7 @@ export function resolveTypeLinks() {
 
       for (const type of asArray(property.type)) {
         if (typeof type === "string") {
-          if (primitives.has(type)) {
+          if (baseTypes.has(type)) {
             ts.push(type);
           } else {
             const t = types[type];
@@ -60,7 +59,7 @@ export function resolveTypeLinks() {
 
       /*
       if (typeof property.type === "string") {
-        if (!primitives.has(property.type)) {
+        if (!baseTypes.has(property.type)) {
           const type = types[property.type];
           if (type) {
             property.type = type;

package/types/services/bind.d.mts

@@ -125,7 +125,7 @@ export class BindService extends ExtraSourceService {
                     get?: Function;
                     env?: string[] | string;
                 };
-                types: typeof string_collection_attribute;
+                types: typeof import("pacc").string_collection_attribute;
                 tls: import("pacc").AttributeDefinition;
                 hostName: {
                     writable: boolean;
@@ -327,7 +327,7 @@ export class BindService extends ExtraSourceService {
                         get?: Function;
                         env?: string[] | string;
                     };
-                    types: typeof string_collection_attribute;
+                    types: typeof import("pacc").string_collection_attribute;
                     tls: import("pacc").AttributeDefinition;
                     hostName: {
                         writable: boolean;
@@ -437,18 +437,18 @@ export class BindService extends ExtraSourceService {
             hasLinkLocalAdresses: import("pacc").AttributeDefinition;
             hasLocationRecord: import("pacc").AttributeDefinition;
             excludeInterfaceKinds: {
-                writable: boolean;
-                collection: boolean;
                 type: string;
                 isKey: boolean;
+                writable: boolean;
                 mandatory: boolean;
-                private: boolean;
-                depends: string;
-                description: string;
-                default: any;
-                set: Function;
-                get: Function;
-                env: string[] | string;
+                collection: boolean;
+                private?: boolean;
+                depends?: string;
+                description?: string;
+                default?: any;
+                set?: Function;
+                get?: Function;
+                env?: string[] | string;
             };
             exclude: {
                 type: string[];
@@ -541,18 +541,18 @@ export class BindService extends ExtraSourceService {
                 env?: string[] | string;
             };
             allowedUpdates: {
-                writable: boolean;
-                collection: boolean;
                 type: string;
                 isKey: boolean;
+                writable: boolean;
                 mandatory: boolean;
-                private: boolean;
-                depends: string;
-                description: string;
-                default: any;
-                set: Function;
-                get: Function;
-                env: string[] | string;
+                collection: boolean;
+                private?: boolean;
+                depends?: string;
+                description?: string;
+                default?: any;
+                set?: Function;
+                get?: Function;
+                env?: string[] | string;
             };
         };
         service: {
@@ -623,4 +623,3 @@ export class BindService extends ExtraSourceService {
     writeZones(packageData: any, configs: any): Promise<void>;
 }
 import { ExtraSourceService } from "pmcf";
-import { string_collection_attribute } from "pacc";

package/types/types.d.mts

@@ -2,4 +2,3 @@ export function addType(clazz: any): void;
 export function resolveTypeLinks(): void;
 export function typeFactory(type: any, owner: any, data: any): any;
 export const types: {};
-export const primitives: Set<string>;