@odx/foundation 0.1.0-alpha.9 → 1.0.0-alpha.2

package/dist/lib/facade/checkbox-group-form-control.js

@@ -0,0 +1,109 @@
+import { isServer } from 'lit';
+import { queryAssignedElements, property } from 'lit/decorators.js';
+import { CheckboxFormControl } from './checkbox-form-control.js';
+import { FormControl } from '../mixins/form-control.js';
+import { CustomElement } from '../models/custom-element.js';
+
+var __defProp = Object.defineProperty;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = void 0 ;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(target, key, result) ) || result;
+  if (result) __defProp(target, key, result);
+  return result;
+};
+const GROUP_CONTROL_SELECTOR = "odx-checkbox-group-control";
+const _CheckboxGroupFormControl = class _CheckboxGroupFormControl extends FormControl(CustomElement) {
+  constructor() {
+    super();
+    this.value = [];
+    this.#handleChangeEvent = (event) => {
+      const { target } = event;
+      if (!this.isControl(target)) return;
+      if (target.checked) {
+        this.updateValue([...this.value, target.value], true);
+        return;
+      }
+      this.updateValue(
+        this.value.filter((value) => value !== target.value),
+        true
+      );
+    };
+    if (!isServer) {
+      this.addEventListener("change", this.#handleChangeEvent);
+    }
+  }
+  get childGroups() {
+    return this.elements.filter((element) => element instanceof _CheckboxGroupFormControl);
+  }
+  get controls() {
+    return this.#findCheckboxControls((element) => !element.hasAttribute(GROUP_CONTROL_SELECTOR)).concat(this.childGroups.flatMap((group) => group.controls));
+  }
+  get groupControls() {
+    return this.#findCheckboxControls((element) => element.hasAttribute(GROUP_CONTROL_SELECTOR));
+  }
+  toFormValue() {
+    const formData = new FormData();
+    this.value.forEach((value, index) => {
+      formData.append(`${this.name}[${index}]`, value);
+    });
+    return formData;
+  }
+  isIndeterminate() {
+    return this.value.length > 0 && this.value.length < this.controls.length;
+  }
+  isControl(element) {
+    return element instanceof CheckboxFormControl;
+  }
+  updated(props) {
+    super.updated(props);
+    if (props.has("value")) {
+      this.updateCheckboxControls((control) => {
+        control.checked = this.value.includes(control.value);
+      });
+      for (const groupControl of this.groupControls) {
+        if (groupControl instanceof CheckboxFormControl && "indeterminate" in groupControl) {
+          groupControl.indeterminate = this.isIndeterminate();
+          groupControl.checked = this.controls.length > 0 && this.value.length === this.controls.length;
+        }
+      }
+    }
+    if (props.has("name")) {
+      this.updateCheckboxControls((control) => {
+        control.name = this.name;
+      });
+    }
+    if (props.has("disabled")) {
+      this.updateCheckboxControls((control) => {
+        control.disabled = this.disabled;
+      });
+    }
+    if (props.has("readonly")) {
+      this.updateCheckboxControls((control) => {
+        control.readonly = this.readonly;
+      });
+    }
+  }
+  updateCheckboxControls(updateFn) {
+    this.controls.forEach(updateFn);
+  }
+  updateValue(value, dispatchEvent) {
+    this.value = value;
+    if (!dispatchEvent) return;
+    this.emit("change");
+  }
+  #handleChangeEvent;
+  #findCheckboxControls(predicate) {
+    return this.elements.filter((element) => this.isControl(element) && predicate(element));
+  }
+};
+__decorateClass([
+  queryAssignedElements({ flatten: true })
+], _CheckboxGroupFormControl.prototype, "elements");
+__decorateClass([
+  property({ type: Array })
+], _CheckboxGroupFormControl.prototype, "value");
+let CheckboxGroupFormControl = _CheckboxGroupFormControl;
+
+export { CheckboxGroupFormControl };

package/dist/lib/facade/index.d.ts

@@ -1,6 +1,6 @@
-export * from './checkbox-control';
-export * from './checkbox-group-control';
+export * from './checkbox-form-control';
+export * from './checkbox-group-form-control';
 export * from './option-control';
-export * from './radio-group-control';
-export * from './select-control';
+export * from './radio-group-form-control';
+export * from './select-form-control';
 //# sourceMappingURL=index.d.ts.map

package/dist/lib/facade/option-control.d.ts

@@ -3,12 +3,12 @@ import { CanBeDisabled } from '../mixins';
 import { CustomElement } from '../models';
 declare const OptionControl_base: import('../mixins').Constructor<CanBeDisabled> & typeof CustomElement;
 export declare abstract class OptionControl extends OptionControl_base {
-    #private;
+    role: 'option' | 'gridcell' | 'row' | 'tab' | null;
     selected: boolean;
     value: string;
     getTextLabel(): string;
-    constructor();
-    toggle(state?: boolean, emitEvent?: boolean): void;
+    setActive(): void;
+    setInactive(): void;
     connectedCallback(): void;
     protected willUpdate(changes: PropertyValueMap<this>): void;
 }

package/dist/lib/facade/option-control.js

@@ -0,0 +1,49 @@
+import { property } from 'lit/decorators.js';
+import { CanBeDisabled } from '../mixins/can-be-disabled.js';
+import { CustomElement } from '../models/custom-element.js';
+import { toAriaBooleanAttribute } from '../directives/aria-boolean-attr.js';
+
+var __defProp = Object.defineProperty;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = void 0 ;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(target, key, result) ) || result;
+  if (result) __defProp(target, key, result);
+  return result;
+};
+class OptionControl extends CanBeDisabled(CustomElement) {
+  constructor() {
+    super(...arguments);
+    this.role = null;
+    this.selected = false;
+    this.value = "";
+  }
+  getTextLabel() {
+    return this.textContent?.trim() ?? "";
+  }
+  setActive() {
+    this.setAttribute("odx-active", "true");
+  }
+  setInactive() {
+    this.removeAttribute("odx-active");
+  }
+  connectedCallback() {
+    super.connectedCallback?.();
+    this.role ||= "option";
+  }
+  willUpdate(changes) {
+    super.willUpdate?.(changes);
+    if (changes.has("selected")) {
+      this.ariaSelected = toAriaBooleanAttribute(this.selected, false);
+    }
+  }
+}
+__decorateClass([
+  property({ type: Boolean })
+], OptionControl.prototype, "selected");
+__decorateClass([
+  property()
+], OptionControl.prototype, "value");
+
+export { OptionControl };

package/dist/lib/facade/radio-group-form-control.d.ts

@@ -0,0 +1,22 @@
+import { PropertyValues } from 'lit';
+import { CustomElement } from '../models';
+import { CheckboxFormControl } from './checkbox-form-control';
+declare const RadioGroupFormControl_base: import('../mixins').Constructor<import('../mixins').IsFormControl<string>> & typeof CustomElement;
+export declare abstract class RadioGroupFormControl extends RadioGroupFormControl_base {
+    #private;
+    static shadowRootOptions: {
+        delegatesFocus: boolean;
+        mode: ShadowRootMode;
+        serializable?: boolean;
+        slotAssignment?: SlotAssignmentMode;
+    };
+    private elements;
+    constructor();
+    getControls(): CheckboxFormControl[];
+    connectedCallback(): void;
+    protected isControl(element: unknown): element is CheckboxFormControl;
+    protected update(changes: PropertyValues<this>): void;
+    protected updateCheckboxControls(updateFn: (control: CheckboxFormControl, index: number) => void): Promise<void>;
+}
+export {};
+//# sourceMappingURL=radio-group-form-control.d.ts.map

package/dist/lib/facade/radio-group-form-control.js

@@ -0,0 +1,87 @@
+import { isServer } from 'lit';
+import { queryAssignedElements } from 'lit/decorators.js';
+import { CheckboxFormControl } from './checkbox-form-control.js';
+import { RovingTabindexController } from '../external/roving-tabindex.js';
+import { FormControl } from '../mixins/form-control.js';
+import { CustomElement } from '../models/custom-element.js';
+
+var __defProp = Object.defineProperty;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = void 0 ;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(target, key, result) ) || result;
+  if (result) __defProp(target, key, result);
+  return result;
+};
+class RadioGroupFormControl extends FormControl(CustomElement) {
+  static {
+    this.shadowRootOptions = {
+      ...CustomElement.shadowRootOptions,
+      delegatesFocus: true
+    };
+  }
+  constructor() {
+    super();
+    if (!isServer) {
+      this.addEventListener("change", this.#handleChange, { capture: true });
+      new RovingTabindexController(this, {
+        direction: "both",
+        elements: () => this.getControls(),
+        elementEnterAction: (element) => element.click(),
+        focusInIndex: (elements) => elements.findIndex((element) => element.checked)
+      });
+    }
+  }
+  getControls() {
+    return this.elements.filter((element) => this.isControl(element));
+  }
+  connectedCallback() {
+    super.connectedCallback?.();
+    this.role ||= "radiogroup";
+  }
+  isControl(element) {
+    return element instanceof CheckboxFormControl;
+  }
+  update(changes) {
+    super.update?.(changes);
+    if (changes.has("value")) {
+      this.updateCheckboxControls((control) => {
+        control.checked = this.value.includes(control.value);
+      });
+    }
+    if (changes.has("name")) {
+      this.updateCheckboxControls((control) => {
+        control.name = this.name;
+      });
+    }
+    if (changes.has("disabled")) {
+      this.updateCheckboxControls((control) => {
+        control.disabled = this.disabled;
+      });
+    }
+    if (changes.has("readonly")) {
+      this.updateCheckboxControls((control) => {
+        control.readonly = this.readonly;
+      });
+    }
+    if (changes.has("required") || changes.has("value")) {
+      const [firstControl] = this.getControls();
+      if (!firstControl) return;
+      this.setValidity({ valueMissing: this.required && this.value.length === 0 }, firstControl);
+    }
+  }
+  async updateCheckboxControls(updateFn) {
+    await 0;
+    this.getControls().forEach(updateFn);
+  }
+  #handleChange = ({ target }) => {
+    if (!this.isControl(target) || this.value === target.value) return;
+    this.value = target.value;
+  };
+}
+__decorateClass([
+  queryAssignedElements({ flatten: true })
+], RadioGroupFormControl.prototype, "elements");
+
+export { RadioGroupFormControl };

package/dist/lib/facade/select-form-control.d.ts

@@ -0,0 +1,19 @@
+import { PropertyValues } from 'lit';
+import { CustomElement } from '../models';
+import { OptionControl } from './option-control';
+declare const SelectFormControl_base: import('../mixins').Constructor<import('../mixins').IsFormControl<string | string[]>> & typeof CustomElement;
+export declare abstract class SelectFormControl<Option extends OptionControl = OptionControl> extends SelectFormControl_base {
+    #private;
+    protected abstract options: Option[];
+    multiple: boolean;
+    value: string[] | string;
+    get selectedOptions(): MapIterator<Option>;
+    constructor();
+    toggle(option: OptionControl, state?: boolean, emitEvent?: boolean): void;
+    protected updateValue(option: OptionControl): void;
+    protected willUpdate(changes: PropertyValues<this>): void;
+    protected updateSelection(): Promise<void>;
+    protected handleKeyboardEvent: (event: KeyboardEvent) => void;
+}
+export {};
+//# sourceMappingURL=select-form-control.d.ts.map

package/dist/lib/facade/select-form-control.js

@@ -0,0 +1,108 @@
+import { isServer } from 'lit';
+import { property } from 'lit/decorators.js';
+import { OptionControl } from './option-control.js';
+import { getElementFromEvent } from '../utils/dom.js';
+import { FormControl } from '../mixins/form-control.js';
+import { CustomElement } from '../models/custom-element.js';
+import { getKeyboardEventInfo } from '../utils/keyboard-events.js';
+
+var __defProp = Object.defineProperty;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = void 0 ;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(target, key, result) ) || result;
+  if (result) __defProp(target, key, result);
+  return result;
+};
+class SelectFormControl extends FormControl(
+  CustomElement
+) {
+  constructor() {
+    super();
+    this.#selectedOptions = /* @__PURE__ */ new Map();
+    this.multiple = false;
+    this.value = "";
+    this.handleKeyboardEvent = (event) => {
+      const { actions } = getKeyboardEventInfo(event);
+      const option = getElementFromEvent(event, (node) => node instanceof OptionControl);
+      if (!option || !actions.enter && !actions.space) return;
+      event.preventDefault();
+      if (event.type === "keydown") return;
+      this.toggle(option, void 0, true);
+    };
+    this.#handleClick = (event) => {
+      const option = getElementFromEvent(event, (node) => node instanceof OptionControl);
+      if (!option) return;
+      this.toggle(option, void 0, true);
+    };
+    if (!isServer) {
+      this.addEventListener("click", this.#handleClick);
+      this.addEventListener("keydown", this.handleKeyboardEvent);
+      this.addEventListener("keyup", this.handleKeyboardEvent);
+    }
+  }
+  #selectedOptions;
+  get selectedOptions() {
+    return this.#selectedOptions.values();
+  }
+  toggle(option, state, emitEvent = false) {
+    const currentState = option.selected;
+    const newState = state ?? !option.selected;
+    if (this.disabled || newState === option.selected) return;
+    option.selected = newState;
+    this.updateValue(option);
+    if (!emitEvent || !this.emit("change")) return;
+    option.selected = currentState;
+    this.updateValue(option);
+  }
+  updateValue(option) {
+    if (this.multiple) {
+      const value = typeof this.value === "string" ? [this.value].filter(Boolean) : this.value;
+      this.value = option.selected ? [...value, option.value] : value.filter((value2) => value2 !== option.value);
+    } else {
+      this.value = option.value;
+    }
+  }
+  willUpdate(changes) {
+    super.willUpdate?.(changes);
+    if (changes.has("multiple")) {
+      const [selectedOption] = Array.from(this.#selectedOptions.entries());
+      if (selectedOption) {
+        this.updateValue(selectedOption[1]);
+      }
+    }
+    if (changes.has("value")) {
+      this.updateSelection();
+    }
+    if (changes.has("required") || changes.has("value")) {
+      const [selectedOption] = this.#selectedOptions.values();
+      if (!selectedOption?.selected) return;
+      this.setValidity({ valueMissing: this.required && this.value.length === 0 }, selectedOption);
+    }
+  }
+  async updateSelection() {
+    if (this.disabled) return;
+    await 0;
+    for (const option of this.options ?? []) {
+      if (option.disabled) continue;
+      option.selected = this.multiple ? this.value.includes(option.value) : this.value === option.value;
+      option.setInactive();
+      if (option.selected) {
+        this.#selectedOptions.set(option.value, option);
+      } else {
+        this.#selectedOptions.delete(option.value);
+      }
+    }
+    this.requestUpdate();
+  }
+  #handleClick;
+}
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], SelectFormControl.prototype, "multiple");
+__decorateClass([
+  property()
+], SelectFormControl.prototype, "value");
+
+export { SelectFormControl };

package/dist/lib/main.d.ts

@@ -0,0 +1,8 @@
+export * from './controllers';
+export * from './directives';
+export * from './external';
+export * from './facade';
+export * from './mixins';
+export * from './models';
+export * from './utils';
+//# sourceMappingURL=main.d.ts.map

package/dist/lib/main.js

@@ -0,0 +1,35 @@
+export { FocusTrapController } from './controllers/focus-trap.controller.js';
+export { fromAriaBooleanAttribute, toAriaBooleanAttribute } from './directives/aria-boolean-attr.js';
+export { optionalAttr } from './directives/optional-attr.js';
+export { optionalSlot } from './directives/optional-slot.js';
+export { emptySlotFallbackFix } from './directives/slot-fallback.js';
+export { FocusGroupController, RovingTabindexController } from './external/roving-tabindex.js';
+export { CheckboxFormControl } from './facade/checkbox-form-control.js';
+export { CheckboxGroupFormControl } from './facade/checkbox-group-form-control.js';
+export { OptionControl } from './facade/option-control.js';
+export { RadioGroupFormControl } from './facade/radio-group-form-control.js';
+export { SelectFormControl } from './facade/select-form-control.js';
+export { CanBeDisabled } from './mixins/can-be-disabled.js';
+export { CanBeReadonly } from './mixins/can-be-readonly.js';
+export { CanBeRequired } from './mixins/can-be-required.js';
+export { CanBeValidated } from './mixins/can-be-validated.js';
+export { dedupeMixin } from './mixins/dedupe-mixin.js';
+export { FormControl } from './mixins/form-control.js';
+export { IsLocalized } from './mixins/is-localized.js';
+export { IsTranslatable } from './mixins/is-translatable.js';
+export { NumberControl } from './mixins/number-control.js';
+export { WithAriaControls } from './mixins/with-aria-controls.js';
+export { WithLoadingState } from './mixins/with-loading-state.js';
+export { CustomElement, customElement } from './models/custom-element.js';
+export { createMutationObserver } from './utils/create-mutation-observer.js';
+export { createOptions } from './utils/create-options.js';
+export { findClosestDocument, getAssignedElements, getElementFromEvent, toPx, toggleAttribute } from './utils/dom.js';
+export { formatDate, formatList, formatNumber, formatRelativeTime, iso8601DateTimeFormat } from './utils/format.js';
+export { clearUniqueIdCache, getUniqueId } from './utils/get-unique-id.js';
+export { KeyboardKey, getKeyboardEventInfo } from './utils/keyboard-events.js';
+export { getLocale, getLocalizationOptions, setLocale, setLocalizationOptions, watchLocaleChanges } from './utils/localization.js';
+export { parseDate } from './utils/parse-date.js';
+export { requestUpdateOnAriaChange } from './utils/request-update-on-aria-change.js';
+export { SharedIntersectionObserver } from './utils/shared-intersection-observer.js';
+export { SharedResizeObserver } from './utils/shared-resize-observer.js';
+export { waitForAnimations } from './utils/wait-for-animations.js';

package/dist/lib/mixins/can-be-disabled.d.ts

@@ -2,6 +2,8 @@ import { CustomElement } from '../models';
 import { Constructor } from './dedupe-mixin';
 export interface CanBeDisabled {
     disabled: boolean;
+    _contextDisabled: boolean;
+    onDisabledChanged?(disabled: boolean): void;
 }
 export declare const CanBeDisabled: <T extends Constructor<CustomElement>>(superClass: T) => Constructor<CanBeDisabled> & T;
 //# sourceMappingURL=can-be-disabled.d.ts.map

package/dist/lib/mixins/can-be-disabled.js

@@ -0,0 +1,60 @@
+import { property } from 'lit/decorators.js';
+import { toAriaBooleanAttribute } from '../directives/aria-boolean-attr.js';
+import { dedupeMixin } from './dedupe-mixin.js';
+
+var __defProp = Object.defineProperty;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = void 0 ;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(target, key, result) ) || result;
+  if (result) __defProp(target, key, result);
+  return result;
+};
+const CanBeDisabled = dedupeMixin((superClass) => {
+  class CanBeDisabledElement extends superClass {
+    constructor() {
+      super(...arguments);
+      this.#initialTabIndex = null;
+      this._contextDisabled = false;
+      this.disabled = false;
+    }
+    #initialTabIndex;
+    connectedCallback() {
+      super.connectedCallback?.();
+      this.#initialTabIndex = this.hasAttribute("tabindex") ? this.tabIndex : null;
+    }
+    willUpdate(props) {
+      super.willUpdate?.(props);
+      if (props.has("_contextDisabled") || props.has("disabled")) {
+        this.#handleDisableChange();
+      }
+    }
+    updated(props) {
+      super.updated?.(props);
+      if (props.has("_contextDisabled") || props.has("disabled")) {
+        this.onDisabledChanged?.(this._contextDisabled || this.disabled);
+      }
+    }
+    #handleDisableChange() {
+      const disabled = this._contextDisabled || this.disabled;
+      this.ariaDisabled = toAriaBooleanAttribute(disabled);
+      if (disabled) {
+        this.tabIndex = -1;
+      } else if (this.#initialTabIndex !== null) {
+        this.tabIndex = this.#initialTabIndex;
+      } else {
+        this.removeAttribute("tabindex");
+      }
+    }
+  }
+  __decorateClass([
+    property({ type: Boolean })
+  ], CanBeDisabledElement.prototype, "_contextDisabled");
+  __decorateClass([
+    property({ type: Boolean })
+  ], CanBeDisabledElement.prototype, "disabled");
+  return CanBeDisabledElement;
+});
+
+export { CanBeDisabled };

package/dist/lib/mixins/can-be-readonly.js

@@ -0,0 +1,33 @@
+import { property } from 'lit/decorators.js';
+import { toAriaBooleanAttribute } from '../directives/aria-boolean-attr.js';
+import { dedupeMixin } from './dedupe-mixin.js';
+
+var __defProp = Object.defineProperty;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = void 0 ;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(target, key, result) ) || result;
+  if (result) __defProp(target, key, result);
+  return result;
+};
+const CanBeReadonly = dedupeMixin((superClass) => {
+  class CanBeReadonlyElement extends superClass {
+    constructor() {
+      super(...arguments);
+      this.readonly = false;
+    }
+    willUpdate(props) {
+      super.willUpdate?.(props);
+      if (props.has("readonly")) {
+        this.ariaReadOnly = toAriaBooleanAttribute(this.readonly);
+      }
+    }
+  }
+  __decorateClass([
+    property({ type: Boolean, reflect: true })
+  ], CanBeReadonlyElement.prototype, "readonly");
+  return CanBeReadonlyElement;
+});
+
+export { CanBeReadonly };

package/dist/lib/mixins/can-be-required.js

@@ -0,0 +1,33 @@
+import { property } from 'lit/decorators.js';
+import { toAriaBooleanAttribute } from '../directives/aria-boolean-attr.js';
+import { dedupeMixin } from './dedupe-mixin.js';
+
+var __defProp = Object.defineProperty;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = void 0 ;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(target, key, result) ) || result;
+  if (result) __defProp(target, key, result);
+  return result;
+};
+const CanBeRequired = dedupeMixin((superClass) => {
+  class CanBeRequiredElement extends superClass {
+    constructor() {
+      super(...arguments);
+      this.required = false;
+    }
+    willUpdate(props) {
+      super.willUpdate?.(props);
+      if (props.has("required")) {
+        this.ariaRequired = toAriaBooleanAttribute(this.required);
+      }
+    }
+  }
+  __decorateClass([
+    property({ type: Boolean, reflect: true })
+  ], CanBeRequiredElement.prototype, "required");
+  return CanBeRequiredElement;
+});
+
+export { CanBeRequired };

package/dist/lib/mixins/can-be-validated.js

@@ -0,0 +1,32 @@
+import { dedupeMixin } from './dedupe-mixin.js';
+
+const CanBeValidated = dedupeMixin((superClass) => {
+  class CanBeValidatedElement extends superClass {
+    constructor() {
+      super(...arguments);
+      this.focusable = true;
+    }
+    get validity() {
+      return this.internals.validity;
+    }
+    get validationMessage() {
+      return this.internals.validationMessage;
+    }
+    get willValidate() {
+      return this.internals.willValidate;
+    }
+    checkValidity() {
+      return this.internals.checkValidity();
+    }
+    reportValidity() {
+      this.internals.reportValidity();
+    }
+    setValidity(flags, target = this) {
+      const errorKey = Object.keys(flags ?? {}).find((key) => flags?.[key] === true);
+      this.internals.setValidity(flags, errorKey ?? "unknown error", target);
+    }
+  }
+  return CanBeValidatedElement;
+});
+
+export { CanBeValidated };

package/dist/lib/mixins/dedupe-mixin.js

@@ -0,0 +1,23 @@
+const appliedClassMixins = /* @__PURE__ */ new WeakMap();
+function wasMixinPreviouslyApplied(mixin, superClass) {
+  let klass = superClass;
+  while (klass) {
+    if (appliedClassMixins.get(klass) === mixin) {
+      return true;
+    }
+    klass = Object.getPrototypeOf(klass);
+  }
+  return false;
+}
+function dedupeMixin(mixin) {
+  return (superClass) => {
+    if (wasMixinPreviouslyApplied(mixin, superClass)) {
+      return superClass;
+    }
+    const mixedClass = mixin(superClass);
+    appliedClassMixins.set(mixedClass, mixin);
+    return mixedClass;
+  };
+}
+
+export { dedupeMixin };