@fluid-topics/ft-wc-utils 1.3.26 → 1.3.27

package/build/FtFormComponent.d.ts

@@ -5,4 +5,4 @@ export type FtFormComponentInterface = {
     get form(): HTMLFormElement | null;
 };
 export type FtFormComponentType<T extends Constructor<FtLitElement>> = T & Constructor<FtFormComponentInterface>;
-export declare function toFtFormComponent<T extends Constructor<FtLitElement>>(ElementClass: T): FtFormComponentType<T>;
+export declare const toFtFormComponent: <T extends Constructor<FtLitElement>>(c: T) => FtFormComponentType<T>;

package/build/FtFormComponent.js

@@ -1,5 +1,6 @@
+import { applyMixinOnce } from "./helpers";
 const elementInternals = Symbol("elementInternals");
-export function toFtFormComponent(ElementClass) {
+export const toFtFormComponent = applyMixinOnce(Symbol("toFtFormComponent"), function (ElementClass) {
     class FtFormComponentClass extends ElementClass {
         static get formAssociated() {
             return true;
@@ -16,4 +17,4 @@ export function toFtFormComponent(ElementClass) {
         }
     }
     return FtFormComponentClass;
-}
+});

package/build/FtLitElementWithAriaNotification.d.ts

@@ -8,5 +8,5 @@ export type FtLitElementWithAriaNotificationInterface = {
     sendAriaNotification(message?: AriaNotificationMessageType): void;
 };
 type FtLitElementWithAriaNotificationType<T extends Constructor<FtLitElement>> = T & Constructor<FtLitElementWithAriaNotificationInterface>;
-export declare function withAriaNotification<T extends Constructor<FtLitElement>>(Class: T): FtLitElementWithAriaNotificationType<T>;
+export declare const withAriaNotification: <T extends Constructor<FtLitElement>>(c: T) => FtLitElementWithAriaNotificationType<T>;
 export {};

package/build/FtLitElementWithAriaNotification.js

@@ -1,5 +1,6 @@
 import { FtNotificationEvent } from "./events";
-export function withAriaNotification(Class) {
+import { applyMixinOnce } from "./helpers";
+export const withAriaNotification = applyMixinOnce(Symbol("withAriaNotification"), function (Class) {
     class FtLitElementWithAriaNotificationClass extends Class {
         sendAriaNotificationIfVisible(message) {
             setTimeout(() => {
@@ -19,4 +20,4 @@ export function withAriaNotification(Class) {
         }
     }
     return FtLitElementWithAriaNotificationClass;
-}
+});

package/build/FtdsBase.d.ts

@@ -7,7 +7,7 @@ export type FtdsBaseInterface = {
     getDesignSystemBaseClasses(): Record<string, boolean>;
 };
 export type FtdsBaseType<T extends Constructor<FtLitElement>> = T & Constructor<FtdsBaseInterface>;
-export declare function toFtdsBase<T extends Constructor<FtLitElement>>(ElementClass: T): FtdsBaseType<T>;
+export declare const toFtdsBase: <T extends Constructor<FtLitElement>>(c: T) => FtdsBaseType<T>;
 declare const FtdsBase_base: FtdsBaseType<typeof FtLitElement>;
 export declare class FtdsBase extends FtdsBase_base {
 }

package/build/FtdsBase.js

@@ -7,7 +7,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { FtLitElement } from "./FtLitElement";
 import { property } from "lit/decorators.js";
 import { DesignSystemFamily, DesignSystemSize, resolveFamilyClass, resolveSizeClass } from "@fluid-topics/design-system-variables";
-export function toFtdsBase(ElementClass) {
+import { applyMixinOnce } from "./helpers";
+export const toFtdsBase = applyMixinOnce(Symbol("toFtdsBase"), function (ElementClass) {
     class FtdsBase extends ElementClass {
         constructor() {
             super(...arguments);
@@ -17,7 +18,7 @@ export function toFtdsBase(ElementClass) {
         getDesignSystemBaseClasses() {
             return {
                 [resolveFamilyClass(this.family)]: true,
-                [resolveSizeClass(this.size)]: true
+                [resolveSizeClass(this.size)]: true,
             };
         }
     }
@@ -28,6 +29,6 @@ export function toFtdsBase(ElementClass) {
         property()
     ], FtdsBase.prototype, "family", void 0);
     return FtdsBase;
-}
+});
 export class FtdsBase extends toFtdsBase(FtLitElement) {
 }

package/build/events.d.ts

@@ -18,7 +18,7 @@ export interface WithEventBusInterface extends EventTarget {
     addEventListener<T extends Event = Event>(type: string, callback: (e: T) => void, options?: AddEventListenerOptions | boolean): void;
     removeEventListener<T extends Event = Event>(type: string, callback: (e: T) => void, options?: EventListenerOptions | boolean): void;
 }
-export declare function withEventBus<T extends Constructor>(Base: T, eventBus?: EventTarget): T & Constructor<WithEventBusInterface>;
+export declare const withEventBus: <T extends Constructor>(c: T) => T & Constructor<WithEventBusInterface>;
 declare const WithEventBus_base: ObjectConstructor & Constructor<WithEventBusInterface>;
 export declare class WithEventBus extends WithEventBus_base {
 }

package/build/events.js

@@ -1,3 +1,4 @@
+import { applyMixinOnce } from "./helpers";
 export class FtNotificationEvent extends CustomEvent {
     constructor(detail) {
         super("ft-notification", { bubbles: true, composed: true, detail });
@@ -13,7 +14,7 @@ export class PostResizeEvent extends Event {
         super("ft-post-resize", { composed: true, bubbles: true });
     }
 }
-export function withEventBus(Base, eventBus) {
+export const withEventBus = applyMixinOnce(Symbol("withEventBus"), function (Base, eventBus) {
     return class extends Base {
         constructor() {
             super(...arguments);
@@ -29,6 +30,6 @@ export function withEventBus(Base, eventBus) {
             this.eventBus.removeEventListener(type, callback, options);
         }
     };
-}
+});
 export class WithEventBus extends withEventBus(Object) {
 }

package/build/ft-input/FtInput.d.ts

@@ -43,4 +43,4 @@ export declare class InputValidationEvent extends CustomEvent<{
 }> {
     constructor(level: string);
 }
-export declare function toFtInput<T extends Constructor<FtLitElement>, V>(ElementClass: T): FtInputType<T, V>;
+export declare const toFtInput: <T extends Constructor<FtLitElement>, V>(c: T) => FtInputType<T, V>;

package/build/ft-input/FtInput.js

@@ -8,6 +8,7 @@ import { property, state } from "lit/decorators.js";
 import { repeat } from "lit/directives/repeat.js";
 import { when } from "lit/directives/when.js";
 import { html } from "lit";
+import { applyMixinOnce } from "../helpers";
 export var ValidateOn;
 (function (ValidateOn) {
     ValidateOn["blur"] = "blur";
@@ -25,7 +26,7 @@ export class InputValidationEvent extends CustomEvent {
         super("input-validated", { detail: { level: level } });
     }
 }
-export function toFtInput(ElementClass) {
+export const toFtInput = applyMixinOnce(Symbol("toFtInput"), function (ElementClass) {
     class FtInput extends ElementClass {
         constructor() {
             super(...arguments);
@@ -90,15 +91,15 @@ export function toFtInput(ElementClass) {
             `;
         }
         resolveStatus() {
-            return this.forceStatus ? this.forceStatus :
-                this.errorMessages.length ? Status.error :
-                    this.warningMessages.length ? Status.warning :
-                        Status.default;
+            return this.forceStatus ? this.forceStatus
+                : this.errorMessages.length ? Status.error
+                    : this.warningMessages.length ? Status.warning
+                        : Status.default;
         }
         processRules(rules) {
-            return rules.map(r => r(this.value))
-                .filter(s => s !== true)
-                .map(e => e);
+            return rules.map((r) => r(this.value))
+                .filter((s) => s !== true)
+                .map((e) => e);
         }
     }
     __decorate([
@@ -153,4 +154,4 @@ export function toFtInput(ElementClass) {
         state()
     ], FtInput.prototype, "additionalErrorRules", void 0);
     return FtInput;
-}
+});