@matter/model 0.11.5-alpha.0-20241112-858f60251 → 0.11.5-alpha.0-20241114-6af665cdd

package/src/models/Aspects.ts

@@ -4,19 +4,40 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import type { Aspect } from "#aspects/Aspect.js";
 import { ModelTraversal } from "../logic/ModelTraversal.js";
 import { Model } from "./Model.js";
 
+// Aspects are immutable, there are not many permutations, and their definitions are largely normalized strings.  So we
+// cache them to keep the object count down
+const aspectCache: Record<string, Record<string, Aspect>> = {
+    Access: {},
+    Conformance: {},
+    Constraint: {},
+    Quality: {},
+};
+
+const emptyAspects: Record<string, Aspect> = {};
+
 export namespace Aspects {
-    export function getAspect<T>(model: Model, symbol: symbol, constructor: new (definition: any) => T) {
-        return ((model as any)[symbol] as T) || ((model as any)[symbol] = new constructor(undefined));
+    export function getAspect<T extends Aspect>(model: Model, symbol: symbol, constructor: new (definition: any) => T) {
+        const aspect = (model as any)[symbol] ?? emptyAspects[constructor.name];
+        if (aspect) {
+            return aspect as T;
+        }
+        return (emptyAspects[constructor.name] = new constructor(undefined));
     }
 
     export function setAspect(model: Model, symbol: symbol, constructor: new (definition: any) => any, value: any) {
         if (value instanceof constructor) {
             (model as any)[symbol] = value;
         } else {
-            (model as any)[symbol] = new constructor(value);
+            const cacheKey = typeof value === "string" ? value : JSON.stringify(value);
+            let aspect = aspectCache[constructor.name][value];
+            if (!aspect) {
+                aspect = aspectCache[constructor.name][cacheKey] = new constructor(value);
+            }
+            (model as any)[symbol] = aspect;
         }
     }
 
@@ -29,7 +50,11 @@ export namespace Aspects {
         }
     }
 
-    export function getEffectiveAspect<T>(model: Model, symbol: symbol, constructor: new (definition: any) => T) {
+    export function getEffectiveAspect<T extends Aspect>(
+        model: Model,
+        symbol: symbol,
+        constructor: new (definition: any) => T,
+    ) {
         const aspect = new ModelTraversal().findAspect(model, symbol) as T | undefined;
         if (aspect) {
             return aspect;

package/src/models/ClusterModel.ts

@@ -202,11 +202,6 @@ export class ClusterModel extends Model<ClusterElement> implements ClusterElemen
         return result as ClusterElement;
     }
 
-    override freeze() {
-        this.quality.freeze();
-        super.freeze();
-    }
-
     constructor(definition: ClusterElement.Properties) {
         super(definition);
 

package/src/models/Model.ts

@@ -32,6 +32,7 @@ export abstract class Model<T extends BaseElement = BaseElement> {
 
     #id?: number = undefined;
     #name: string;
+    #frozen?: boolean;
 
     /**
      * Indicates that an element may have type definitions as children.
@@ -44,13 +45,19 @@ export abstract class Model<T extends BaseElement = BaseElement> {
     isType?: boolean;
 
     /**
-     * Normally {@link base} performs lookup based on {@link type}.  If instead a model is installed it is used as the
-     * base.
+     * Normally {@link base} performs lookup based on {@link type}.  Setting this field short circuits this resolution.
      *
      * The operational base also enables resolution from the operational base's tree.  This enables resolution on
      * operational models that are not installed in a parent hierarchy.
+     *
+     * We set the operational base when freezing the model.
      */
-    operationalBase?: Model;
+    operationalBase?: Model | null;
+
+    /**
+     * This is like {@link operationalBase} except for the element's shadow.
+     */
+    operationalShadow?: Model | null;
 
     #children?: Children<Model>;
     #parent?: Model;
@@ -224,14 +231,20 @@ export abstract class Model<T extends BaseElement = BaseElement> {
     /**
      * Get a model for my base type as defined by {@link type}, if any.
      */
-    get base() {
+    get base(): Model | undefined {
+        if (this.operationalBase !== undefined) {
+            return this.operationalBase ?? undefined;
+        }
         return new ModelTraversal().findBase(this);
     }
 
     /**
      * Get shadow model, if any.  A "shadow" is an element in my parent's inheritance hierarchy that I override.
      */
-    get shadow() {
+    get shadow(): Model | undefined {
+        if (this.operationalShadow !== undefined) {
+            return this.operationalShadow ?? undefined;
+        }
         return new ModelTraversal().findShadow(this);
     }
 
@@ -453,14 +466,22 @@ export abstract class Model<T extends BaseElement = BaseElement> {
      * Freeze the model hierarchy rooted at this model.
      *
      * When using a model as operational schema we implement various optimizations that assume the schema is immutable.
-     * This function enforces that assumption.
+     * This function enforces that assumption and caches a few values that only make sense with frozen schema.
      *
      * To make changes to a frozen model use {@link clone}.
      */
     freeze() {
+        if (this.#frozen) {
+            return;
+        }
+
+        const base = this.operationalBase ?? (this.operationalBase = this.base ?? null);
+        const shadow = this.operationalShadow ?? (this.operationalShadow = this.shadow ?? null);
+        this.#frozen = true;
         Object.freeze(this);
         this.children.freeze();
-        this.base?.freeze();
+        base?.freeze();
+        shadow?.freeze();
     }
 
     toString() {

package/src/models/ValueModel.ts

@@ -304,14 +304,6 @@ export abstract class ValueModel<T extends ValueElement = ValueElement> extends
         return result as T;
     }
 
-    override freeze() {
-        this.constraint.freeze();
-        this.conformance.freeze();
-        this.access.freeze();
-        this.quality.freeze();
-        super.freeze();
-    }
-
     constructor(definition: BaseElement.Properties<T>) {
         super(definition);
 

package/src/standard/elements/LevelControl.ts

@@ -224,9 +224,9 @@ export const LevelControl = Cluster({
             children: [
                 Field({ name: "Level", id: 0x0, type: "uint8", conformance: "M", constraint: "0 to 254" }),
                 Field({ name: "TransitionTime", id: 0x1, type: "uint16", conformance: "M", quality: "X" }),
-                Field({ name: "OptionsMask", id: 0x2, type: "Options", conformance: "O", constraint: "desc", default: 0 }),
+                Field({ name: "OptionsMask", id: 0x2, type: "Options", conformance: "M", constraint: "desc", default: 0 }),
                 Field({
-                    name: "OptionsOverride", id: 0x3, type: "Options", conformance: "O", constraint: "desc", default: 0
+                    name: "OptionsOverride", id: 0x3, type: "Options", conformance: "M", constraint: "desc", default: 0
                 })
             ]
         }),