@matter/types 0.11.0-alpha.0-20241005-e3e4e4a7a

package/dist/esm/cluster/mutation/ClusterComposer.d.ts

@@ -0,0 +1,115 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MatterError } from "#general";
+import { ClusterType } from "../ClusterType.js";
+export declare class IllegalClusterError extends MatterError {
+}
+/**
+ * A "cluster composer" manages cluster configuration based on feature selection.
+ */
+export declare class ClusterComposer<const T extends ClusterType> {
+    cluster: T;
+    constructor(cluster: T);
+    /**
+     * Build a cluster using selected feature flags.
+     *
+     * @param selection the name(s) of optional features to support
+     * @throws {IllegalClusterError} if the feature combination is disallowed by the Matter specification
+     */
+    compose<const SelectionT extends ClusterComposer.FeatureSelection<T>>(selection: SelectionT): ClusterComposer.Of<T, SelectionT>;
+    /**
+     * Validates a set of feature flags against the features supported by a cluster.
+     */
+    private validateFeatureSelection;
+    /**
+     * Injects a component into a cluster if the cluster supports the specified features.  Uses matching element from
+     * "original" if present.  This allows for component insertion without overwrite of other changes to the named
+     * element.
+     */
+    private accept;
+    static injectElements(definition: Partial<ClusterType.Options>, component: Partial<ClusterType.Options>, original?: Partial<ClusterType>): void;
+    /**
+     * Throws an error if a feature combination is illegal per the Matter specification.
+     */
+    private reject;
+}
+export declare namespace ClusterComposer {
+    type Component = Partial<ClusterType.Elements>;
+    /**
+     * An array of names indicating features to be injected.
+     */
+    type FeatureSelection<T extends ClusterType> = readonly Capitalize<string & keyof T["features"]>[];
+    /**
+     * A set of boolean values indicating whether a feature is enabled.
+     */
+    type FeatureFlags = Record<string, boolean | undefined>;
+    /**
+     * Describes the output of {@link ClusterComposer.compose}.
+     */
+    type Of<ClusterT extends ClusterType, FeaturesT extends FeatureSelection<ClusterT>> = WithFeatures<ClusterT, FeaturesT>;
+    /**
+     * The base of a cluster.
+     */
+    type BaseOf<T extends ClusterType> = T["base"] extends ClusterType ? T["base"] : T;
+    /**
+     * The result of composition.
+     */
+    type WithFeatures<ClusterT extends ClusterType, FeaturesT extends FeatureSelection<BaseOf<ClusterT>>> = Omit<BaseOf<ClusterT>, "supportedFeatures" | "base" | ElementType> & {
+        supportedFeatures: FeaturesAsFlags<BaseOf<ClusterT>, FeaturesT>;
+        base: BaseOf<ClusterT>;
+    } & ExtendedElements<ClusterT, SelectedElements<FeaturesAsFlags<ClusterT, FeaturesT>, ClusterT["extensions"] extends object ? ClusterT["extensions"] : []>>;
+    /**
+     * Convert a {@link FeatureSelection} array into a {@link FeatureFlags} object.
+     */
+    type FeaturesAsFlags<ClusterT extends ClusterType, FlagsT extends FeatureSelection<ClusterT>> = {
+        [K in keyof ClusterT["features"]]: K extends string ? Capitalize<K> extends `${FlagsT[number]}` ? true : false : never;
+    };
+    /**
+     * Choose elements from applicable extensions.
+     */
+    type SelectedElements<FlagsT extends FeatureFlags, extensionsT extends readonly ClusterType.Extension[]> = extensionsT extends readonly [
+        infer S extends ClusterType.Extension,
+        ...infer R extends readonly ClusterType.Extension[]
+    ] ? SelectorContribution<FlagsT, S> & SelectedElements<FlagsT, R> : {};
+    /**
+     * Determine the type contributed to feature selection by a specific selector.
+     */
+    type SelectorContribution<FlagsT extends FeatureFlags, SelectorT extends ClusterType.Extension> = FlagsT extends SelectorT["flags"] ? SelectorT["component"] extends false ? never : SelectorT["component"] & {
+        attributes: {};
+        commands: {};
+        events: {};
+    } : {
+        attributes: {};
+        commands: {};
+        events: {};
+    };
+    /**
+     * Cluster elements extended with .
+     *
+     * Note that we have to track the base separate from the originating cluster.  If we are removing features, we want
+     * to maintain only those features present in the base or selected components.
+     */
+    type ExtendedElements<ClusterT extends ClusterType, ComponentT extends Component> = [ComponentT] extends [
+        never
+    ] ? never : {
+        [TypeT in ElementType]: Pick<ClusterT[TypeT], keyof ClusterT[TypeT] & (keyof BaseOf<ClusterT>[TypeT] | keyof ComponentT[TypeT])> & Omit<ComponentT[TypeT], keyof ClusterT[TypeT]> & Omit<BaseOf<ClusterT>[TypeT], keyof ClusterT[TypeT] | keyof ComponentT[TypeT]>;
+    };
+    /**
+     * A cluster extended by multiple components.
+     */
+    type WithComponents<ClusterT extends ClusterType, RestT extends Component[]> = RestT extends [
+        infer ComponentT extends Component,
+        ...infer RestT extends Component[]
+    ] ? WithComponents<Omit<ClusterT, ElementType> & ExtendedElements<ClusterT, ComponentT>, RestT> : ClusterT;
+    /**
+     * A "WritableDefinition" is a Cluster with fields that may be modified.
+     */
+    type WritableDefinition = {
+        -readonly [Key in keyof ClusterType]: ClusterType[Key];
+    };
+    type ElementType = "attributes" | "commands" | "events";
+}
+//# sourceMappingURL=ClusterComposer.d.ts.map

package/dist/esm/cluster/mutation/ClusterComposer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClusterComposer.d.ts","sourceRoot":"","sources":["../../../../src/cluster/mutation/ClusterComposer.ts"],"names":[],"mappings":"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"}

package/dist/esm/cluster/mutation/ClusterComposer.js

@@ -0,0 +1,131 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { camelize, isDeepEqual, MatterError, serialize } from "#general";
+import { BitFlags } from "../../schema/BitmapSchema.js";
+import { ClusterType } from "../ClusterType.js";
+class IllegalClusterError extends MatterError {
+}
+class ClusterComposer {
+  constructor(cluster) {
+    this.cluster = cluster;
+  }
+  /**
+   * Build a cluster using selected feature flags.
+   *
+   * @param selection the name(s) of optional features to support
+   * @throws {IllegalClusterError} if the feature combination is disallowed by the Matter specification
+   */
+  compose(selection) {
+    this.validateFeatureSelection(selection);
+    const extensions = this.cluster.extensions;
+    let cluster;
+    if (extensions) {
+      const base = this.cluster.base ?? this.cluster;
+      const baseElements = (type) => {
+        const elements = {};
+        const clusterElements = this.cluster[type];
+        for (const name in base[type]) {
+          elements[name] = clusterElements[name] ?? base[type][name];
+        }
+        return elements;
+      };
+      cluster = ClusterType({
+        ...base,
+        attributes: baseElements("attributes"),
+        commands: baseElements("commands"),
+        events: baseElements("events"),
+        supportedFeatures: BitFlags(this.cluster.features, ...selection),
+        base
+      });
+      for (const selector of extensions) {
+        if (selector.component) {
+          this.accept(cluster, selector.component, this.cluster, selector.flags);
+        } else {
+          this.reject(cluster, selector.flags);
+        }
+      }
+    } else {
+      const supportedFeatures = BitFlags(this.cluster.features, ...selection);
+      if (isDeepEqual(supportedFeatures, this.cluster.supportedFeatures)) {
+        cluster = this.cluster;
+      } else {
+        cluster = ClusterType({
+          ...this.cluster,
+          supportedFeatures,
+          base: this.cluster.base ?? this.cluster
+        });
+      }
+    }
+    return cluster;
+  }
+  /**
+   * Validates a set of feature flags against the features supported by a cluster.
+   */
+  validateFeatureSelection(features) {
+    for (const f of features) {
+      if (!this.cluster.features[camelize(f)]) {
+        throw new IllegalClusterError(`"${f}" is not a valid feature identifier`);
+      }
+    }
+  }
+  /**
+   * Injects a component into a cluster if the cluster supports the specified features.  Uses matching element from
+   * "original" if present.  This allows for component insertion without overwrite of other changes to the named
+   * element.
+   */
+  accept(definition, component, original, flags) {
+    for (const k in flags) {
+      if (!!definition.supportedFeatures[k] !== !!flags[k]) {
+        return;
+      }
+    }
+    ClusterComposer.injectElements(definition, component, original);
+  }
+  static injectElements(definition, component, original) {
+    function installElements(name) {
+      const src = component[name];
+      if (!src) {
+        return;
+      }
+      let dest = definition[name];
+      if (dest) {
+        dest = { ...dest };
+      } else {
+        dest = {};
+      }
+      definition[name] = dest;
+      for (const key in src) {
+        const orig = original?.[name]?.[key];
+        if (orig) {
+          dest[key] = orig;
+        } else {
+          dest[key] = src[key];
+        }
+      }
+    }
+    installElements("attributes");
+    installElements("commands");
+    installElements("events");
+  }
+  /**
+   * Throws an error if a feature combination is illegal per the Matter specification.
+   */
+  reject(definition, flags) {
+    for (const k in flags) {
+      if (!!definition.supportedFeatures[k] !== !!flags[k]) {
+        return;
+      }
+    }
+    throw new IllegalClusterError(
+      `Feature combination ${serialize(flags)} is disallowed by the Matter specification`
+    );
+  }
+}
+export {
+  ClusterComposer,
+  IllegalClusterError
+};
+//# sourceMappingURL=ClusterComposer.js.map

package/dist/esm/cluster/mutation/ClusterComposer.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/cluster/mutation/ClusterComposer.ts"],
+  "mappings": "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",
+  "names": []
+}

package/dist/esm/cluster/mutation/ElementModifier.d.ts

@@ -0,0 +1,124 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ClusterType } from "../ClusterType.js";
+/**
+ * An "element modifier" mutates cluster elements based on a predefined set of
+ * alterations described in the Matter device library.
+ */
+export declare class ElementModifier<const T extends ClusterType> {
+    cluster: T;
+    constructor(cluster: T);
+    /**
+     * Create a new cluster with modified elements.
+     */
+    alter<const AlterationsT extends ElementModifier.Alterations<T>>(alterations: AlterationsT): ElementModifier.WithAlterations<T, AlterationsT>;
+    /**
+     * Create a new cluster with different attribute defaults.
+     *
+     * This "sets" the values of attributes when the cluster is created
+     * for the first time with no persistent state.
+     */
+    set<const ValuesT extends Partial<ClusterType.InputAttributeValues<T>>>(values: ValuesT): ElementModifier.WithValues<T, ValuesT>;
+    /**
+     * Create a new cluster with additional features marked "mandatory".
+     *
+     * This informs matter.js that an application supports these elements.
+     */
+    enable<const FlagsT extends ElementModifier.ElementFlags<T>>(flags: FlagsT): ElementModifier.WithAlterations<T, ElementModifier.ElementFlagAlterations<FlagsT>>;
+}
+export declare namespace ElementModifier {
+    /**
+     * A set of modifications to cluster elements of a specific type.
+     */
+    type ElementSetAlterations<AlterationT extends ElementAlteration, ElementSetT> = {
+        [name in keyof ElementSetT]?: AlterationT;
+    };
+    interface ElementAlteration {
+        optional?: boolean;
+    }
+    interface AttributeAlteration extends ElementAlteration {
+        default?: any;
+        min?: any;
+        max?: any;
+    }
+    /**
+     * A set of modifications to a cluster's elements.
+     *
+     * Note - cannot specify ElementsT as extending ClusterElements because it
+     * triggers a bug in TS 5.2 declaration generation
+     */
+    type Alterations<OriginalT extends ClusterType> = {
+        attributes?: ElementSetAlterations<AttributeAlteration, OriginalT["attributes"]>;
+        commands?: ElementSetAlterations<ElementAlteration, OriginalT["commands"]>;
+        events?: ElementSetAlterations<ElementAlteration, OriginalT["events"]>;
+    };
+    /**
+     * Alterations applied to a specific element set, element or element field.
+     */
+    type AlteredElements<OriginalT, ElementT, AlterationT> = {
+        [name in keyof OriginalT]: OriginalT[name] extends infer OrigT extends ElementT ? AlterationT extends {
+            [n in name]: {
+                optional: infer O extends boolean;
+            };
+        } ? Omit<OrigT, "optional"> & {
+            optional: O;
+        } : OrigT : never;
+    };
+    /**
+     * A definition with alterations applied.
+     */
+    type WithAlterations<T extends ClusterType, AlterationsT extends Alterations<any>> = Omit<T, "attributes" | "commands" | "events"> & {
+        attributes: AlteredElements<T["attributes"], ClusterType.Attribute, AlterationsT["attributes"]>;
+        commands: AlteredElements<T["commands"], ClusterType.Command, AlterationsT["commands"]>;
+        events: AlteredElements<T["events"], ClusterType.Event, AlterationsT["events"]>;
+    };
+    /**
+     * A definition with attribute defaults updated.
+     */
+    type WithValues<T extends ClusterType, ValuesT extends Partial<ClusterType.InputAttributeValues<T>>> = WithAlterations<T, AttributeValueAlterations<ValuesT>>;
+    /**
+     * A definition with elements enabled.
+     */
+    type WithFlags<T extends ClusterType, FlagsT extends ElementFlags<T>> = WithAlterations<T, ElementFlagAlterations<FlagsT>>;
+    /**
+     * Alterations implied by AttributeValues.
+     */
+    type AttributeValueAlterations<ValuesT extends Partial<ClusterType.InputAttributeValues<any>>> = {
+        attributes: {
+            [K in keyof ValuesT]: {
+                default: ValuesT[K];
+            };
+        };
+    };
+    type ElementSetFlags<ElementsT extends ClusterType.ElementSet<any> | undefined> = {
+        [key in keyof ElementsT]?: boolean;
+    };
+    /**
+     * Flags indicating elements to enable.
+     */
+    type ElementFlags<ClusterT extends ClusterType> = {
+        attributes?: ElementSetFlags<ClusterType.AttributesOf<ClusterT>>;
+        commands?: ElementSetFlags<ClusterType.CommandsOf<ClusterT>>;
+        events?: ElementSetFlags<ClusterType.EventsOf<ClusterT>>;
+    };
+    type ElementSetFlagAlterations<ElementsT extends ElementSetFlags<any> | undefined> = ElementsT extends {} ? {
+        [key in keyof ElementsT]: {
+            optional: ElementsT[key] extends true ? false : true;
+        };
+    } : undefined;
+    /**
+     * Alterations implied by ElementFlags.
+     */
+    type ElementFlagAlterations<T extends ElementFlags<any>> = {
+        [K in keyof T]: T[K] extends ElementSetFlags<any> ? ElementSetFlagAlterations<T[K]> : never;
+    };
+    /**
+     * An "extender" is a function that creates a cluster with specific
+     * features enabled.
+     */
+    type Extender = (...features: any) => ClusterType;
+}
+//# sourceMappingURL=ElementModifier.d.ts.map

package/dist/esm/cluster/mutation/ElementModifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ElementModifier.d.ts","sourceRoot":"","sources":["../../../../src/cluster/mutation/ElementModifier.ts"],"names":[],"mappings":"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"}

package/dist/esm/cluster/mutation/ElementModifier.js

@@ -0,0 +1,80 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class ElementModifier {
+  constructor(cluster) {
+    this.cluster = cluster;
+  }
+  /**
+   * Create a new cluster with modified elements.
+   */
+  alter(alterations) {
+    return modifyElements(this.cluster, alterations, (element, alteration) => {
+      for (const property in alteration) {
+        element[property] = alteration[property];
+      }
+    });
+  }
+  /**
+   * Create a new cluster with different attribute defaults.
+   *
+   * This "sets" the values of attributes when the cluster is created
+   * for the first time with no persistent state.
+   */
+  set(values) {
+    return modifyElements(this.cluster, { attributes: values }, (element, defaultValue) => {
+      element.default = defaultValue;
+    });
+  }
+  /**
+   * Create a new cluster with additional features marked "mandatory".
+   *
+   * This informs matter.js that an application supports these elements.
+   */
+  enable(flags) {
+    return modifyElements(this.cluster, flags, (element, flag) => {
+      if (flag === true) {
+        element.optional = false;
+      } else if (flag === false) {
+        element.optional = true;
+      }
+    });
+  }
+}
+function modifyElements(definition, modifications, modifier) {
+  const result = { ...definition };
+  for (const elementType of ["attributes", "commands", "events"]) {
+    const mods = modifications[elementType];
+    if (mods === void 0) {
+      continue;
+    }
+    let elements = result[elementType];
+    if (elements === void 0) {
+      continue;
+    }
+    let replaced = false;
+    for (const elementName in mods) {
+      const mod = mods[elementName];
+      if (mod === void 0) {
+        continue;
+      }
+      const element = elements[elementName];
+      if (!element) {
+        continue;
+      }
+      if (!replaced) {
+        elements = result[elementType] = { ...result[elementType] };
+        replaced = true;
+      }
+      elements[elementName] = { ...element };
+      modifier(elements[elementName], mod);
+    }
+  }
+  return result;
+}
+export {
+  ElementModifier
+};
+//# sourceMappingURL=ElementModifier.js.map

package/dist/esm/cluster/mutation/ElementModifier.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/cluster/mutation/ElementModifier.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAYO,MAAM,gBAA6C;AAAA,EACtD,YAAmB,SAAY;AAAZ;AAAA,EAAa;AAAA;AAAA;AAAA;AAAA,EAKhC,MAAiE,aAA2B;AACxF,WAAO,eAAe,KAAK,SAAS,aAAa,CAAC,SAAS,eAAoB;AAC3E,iBAAW,YAAY,YAAY;AAC/B,gBAAQ,QAAQ,IAAI,WAAW,QAAQ;AAAA,MAC3C;AAAA,IACJ,CAAC;AAAA,EACL;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,IAAwE,QAAiB;AACrF,WAAO,eAAe,KAAK,SAAS,EAAE,YAAY,OAAO,GAAG,CAAC,SAAS,iBAAiB;AACnF,cAAQ,UAAU;AAAA,IACtB,CAAC;AAAA,EACL;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAA6D,OAAe;AACxE,WAAO,eAAe,KAAK,SAAS,OAAO,CAAC,SAAS,SAAS;AAC1D,UAAI,SAAS,MAAM;AACf,gBAAQ,WAAW;AAAA,MACvB,WAAW,SAAS,OAAO;AACvB,gBAAQ,WAAW;AAAA,MACvB;AAAA,IACJ,CAAC;AAAA,EACL;AACJ;AAkHA,SAAS,eACL,YACA,eACA,UACF;AACE,QAAM,SAAS,EAAE,GAAG,WAAW;AAE/B,aAAW,eAAe,CAAC,cAAc,YAAY,QAAQ,GAAY;AACrE,UAAM,OAAO,cAAc,WAAW;AACtC,QAAI,SAAS,QAAW;AACpB;AAAA,IACJ;AAEA,QAAI,WAAW,OAAO,WAAW;AACjC,QAAI,aAAa,QAAW;AACxB;AAAA,IACJ;AAEA,QAAI,WAAW;AAEf,eAAW,eAAe,MAAM;AAC5B,YAAM,MAAM,KAAK,WAAW;AAC5B,UAAI,QAAQ,QAAW;AACnB;AAAA,MACJ;AAEA,YAAM,UAAU,SAAS,WAAW;AACpC,UAAI,CAAC,SAAS;AACV;AAAA,MACJ;AAEA,UAAI,CAAC,UAAU;AACX,mBAAW,OAAO,WAAW,IAAI,EAAE,GAAG,OAAO,WAAW,EAAE;AAC1D,mBAAW;AAAA,MACf;AAEA,eAAS,WAAW,IAAI,EAAE,GAAG,QAAQ;AAErC,eAAS,SAAS,WAAW,GAAG,GAAG;AAAA,IACvC;AAAA,EACJ;AAEA,SAAO;AACX;",
+  "names": []
+}

package/dist/esm/cluster/mutation/MutableCluster.d.ts

@@ -0,0 +1,75 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ClusterId } from "../../datatype/ClusterId.js";
+import { ConditionalFeatureList } from "../Cluster.js";
+import { ClusterType } from "../ClusterType.js";
+import { ClusterComposer } from "./ClusterComposer.js";
+import { ElementModifier } from "./ElementModifier.js";
+/**
+ * A "mutable cluster" is a {@link ClusterType} with builder methods that support a limited number of modifications as
+ * defined by the Matter specification.
+ */
+export type MutableCluster<T extends ClusterType.Options, C extends ClusterComposer.Component[] = []> = ClusterComposer.WithComponents<ClusterType.Of<T>, C> & MutableCluster.Methods<ClusterType.Of<T>>;
+/**
+ * Define a new {@link MutableCluster}.
+ */
+export declare function MutableCluster<const T extends ClusterType.Options, const C extends ClusterComposer.Component[]>(options: T, ...components: C): MutableCluster<T, C>;
+export declare namespace MutableCluster {
+    /**
+     * Define a component.
+     */
+    function Component<const T extends Partial<ClusterType.Options>>(elements: T): T;
+    /**
+     * Define a cluster's extension set.
+     */
+    function Extensions<const T extends readonly ClusterType.Extension[]>(...extensions: T): T;
+    interface Methods<T extends ClusterType> {
+        /**
+         * Select features using {@link ClusterComposer.compose}.
+         */
+        with<const SelectionT extends ClusterComposer.FeatureSelection<T>>(...selection: SelectionT): ClusterComposer.Of<T, SelectionT>;
+        /**
+         * Modify elements using {@link ElementModifier.alter}.
+         */
+        alter<const AlterationsT extends ElementModifier.Alterations<T>>(alterations: AlterationsT): ElementModifier.WithAlterations<T, AlterationsT>;
+        /**
+         * Modify elements using {@link ElementModifier.set}.
+         */
+        set<const ValuesT extends ClusterType.InputAttributeValues<T>>(values: ValuesT): ElementModifier.WithValues<T, ValuesT>;
+        /**
+         * Modify elements using {@link ElementModifier.enable}.
+         */
+        enable<const FlagsT extends ElementModifier.ElementFlags<T>>(flags: FlagsT): ElementModifier.WithFlags<T, FlagsT>;
+    }
+    /**
+     * ExtensibleOnly creates a factory that produces a {@link MutableCluster} when the user selects features.
+     *
+     * We define clusters this way if the Matter specification defines a cluster with a set of features, one of which is
+     * required, but none of which is required if others are enabled.
+     */
+    interface ExtensibleOnly<T extends ClusterType.Options> {
+        id: ClusterId;
+        name: string;
+        with: Methods<ClusterType.Of<T>>["with"];
+    }
+    /**
+     * Create a factory for clusters that require extension.
+     */
+    function ExtensibleOnly<const T extends ClusterType.Options>(options: T): ExtensibleOnly<T>;
+    /**
+     * Create a conditional version of an unconditional element definition.
+     */
+    function AsConditional<const ClusterT extends ClusterType, const E extends ClusterType.Attribute | ClusterType.Command | ClusterType.Event, const OI extends ConditionalFeatureList<ClusterT["features"]>, const MI extends ConditionalFeatureList<ClusterT["features"]>>(element: E, { optionalIf, mandatoryIf }: {
+        optionalIf?: OI;
+        mandatoryIf?: MI;
+    }): E & {
+        readonly optional: true;
+        readonly isConditional: true;
+        readonly optionalIf: [] | OI;
+        readonly mandatoryIf: [] | MI;
+    };
+}
+//# sourceMappingURL=MutableCluster.d.ts.map

package/dist/esm/cluster/mutation/MutableCluster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MutableCluster.d.ts","sourceRoot":"","sources":["../../../../src/cluster/mutation/MutableCluster.ts"],"names":[],"mappings":"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"}

package/dist/esm/cluster/mutation/MutableCluster.js

@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ClusterType } from "../ClusterType.js";
+import { ClusterComposer } from "./ClusterComposer.js";
+import { ElementModifier } from "./ElementModifier.js";
+function MutableCluster(options, ...components) {
+  const cluster = ClusterType(options);
+  for (const component of components) {
+    ClusterComposer.injectElements(cluster, component);
+  }
+  Object.assign(cluster, {
+    with(...features) {
+      return new ClusterComposer(cluster).compose(features);
+    },
+    alter(alterations) {
+      return new ElementModifier(cluster).alter(alterations);
+    },
+    set(values) {
+      return new ElementModifier(cluster).set(values);
+    },
+    enable(flags) {
+      return new ElementModifier(cluster).enable(flags);
+    }
+  });
+  return cluster;
+}
+((MutableCluster2) => {
+  function Component(elements) {
+    return elements;
+  }
+  MutableCluster2.Component = Component;
+  function Extensions(...extensions) {
+    return extensions;
+  }
+  MutableCluster2.Extensions = Extensions;
+  function ExtensibleOnly(options) {
+    return {
+      id: options.id,
+      name: options.name,
+      with(...features) {
+        return new ClusterComposer(ClusterType(options)).compose(features);
+      }
+    };
+  }
+  MutableCluster2.ExtensibleOnly = ExtensibleOnly;
+  function AsConditional(element, { optionalIf, mandatoryIf }) {
+    return {
+      ...element,
+      optional: true,
+      isConditional: true,
+      optionalIf: optionalIf ?? [],
+      mandatoryIf: mandatoryIf ?? []
+    };
+  }
+  MutableCluster2.AsConditional = AsConditional;
+})(MutableCluster || (MutableCluster = {}));
+export {
+  MutableCluster
+};
+//# sourceMappingURL=MutableCluster.js.map

package/dist/esm/cluster/mutation/MutableCluster.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/cluster/mutation/MutableCluster.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,SAAS,mBAAmB;AAC5B,SAAS,uBAAuB;AAChC,SAAS,uBAAuB;AAczB,SAAS,eACZ,YACG,YACL;AACE,QAAM,UAAU,YAAY,OAAO;AAEnC,aAAW,aAAa,YAAY;AAChC,oBAAgB,eAAe,SAAS,SAAS;AAAA,EACrD;AAEA,SAAO,OAAO,SAAS;AAAA,IACnB,QAAQ,UAA4D;AAChE,aAAO,IAAI,gBAAgB,OAAO,EAAE,QAAQ,QAAQ;AAAA,IACxD;AAAA,IAEA,MAAM,aAA0D;AAC5D,aAAO,IAAI,gBAAgB,OAAO,EAAE,MAAM,WAAW;AAAA,IACzD;AAAA,IAEA,IAAI,QAA0D;AAC1D,aAAO,IAAI,gBAAgB,OAAO,EAAE,IAAI,MAAM;AAAA,IAClD;AAAA,IAEA,OAAO,OAAqD;AACxD,aAAO,IAAI,gBAAgB,OAAO,EAAE,OAAO,KAAK;AAAA,IACpD;AAAA,EACJ,CAAC;AAED,SAAO;AACX;AAAA,CAEO,CAAUA,oBAAV;AAII,WAAS,UAAwD,UAAa;AACjF,WAAO;AAAA,EACX;AAFO,EAAAA,gBAAS;AAOT,WAAS,cAAgE,YAAe;AAC3F,WAAO;AAAA,EACX;AAFO,EAAAA,gBAAS;AAkDT,WAAS,eAAoD,SAAY;AAC5E,WAAO;AAAA,MACH,IAAI,QAAQ;AAAA,MACZ,MAAM,QAAQ;AAAA,MAEd,QAAQ,UAA+D;AACnE,eAAO,IAAI,gBAAgB,YAAY,OAAO,CAAC,EAAE,QAAQ,QAAQ;AAAA,MACrE;AAAA,IACJ;AAAA,EACJ;AATO,EAAAA,gBAAS;AAcT,WAAS,cAKd,SAAY,EAAE,YAAY,YAAY,GAA0C;AAC9E,WAAO;AAAA,MACH,GAAG;AAAA,MACH,UAAU;AAAA,MACV,eAAe;AAAA,MACf,YAAY,cAAc,CAAC;AAAA,MAC3B,aAAa,eAAe,CAAC;AAAA,IACjC;AAAA,EACJ;AAbO,EAAAA,gBAAS;AAAA,GA3EH;",
+  "names": ["MutableCluster"]
+}

package/dist/esm/cluster/mutation/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./ClusterComposer.js";
+export * from "./ElementModifier.js";
+export * from "./MutableCluster.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/cluster/mutation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cluster/mutation/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC"}