@wirekyt/angular 0.0.1 → 0.0.3

package/dist/fesm2022/wirekyt-angular.mjs

@@ -0,0 +1,1011 @@
+import { createScope, MachineStatus, hasTag, matchesState, getExitEnterStates, INIT_STATE, resolveStateValue, findTransition } from '@wirekyt/dom';
+export { mergeProps } from '@wirekyt/dom';
+import * as i0 from '@angular/core';
+import { RendererStyleFlags2, effect, inject, DestroyRef, signal, computed, untracked, afterNextRender, InjectionToken, PLATFORM_ID, Injectable, createComponent, Injector, isDevMode } from '@angular/core';
+import { compact, isFunction, toArray, warn, isString, ensure, isEqual, callAll } from '@wirekyt/dom/utils';
+import { createNormalizer } from '@wirekyt/dom/types';
+import { isPlatformBrowser, DOCUMENT } from '@angular/common';
+
+const isAttributeKey = (key) => key === "role" ||
+    key === "id" ||
+    key === "tabindex" ||
+    key.startsWith("aria-") ||
+    key.startsWith("data-");
+const eventNameFromHandlerKey = (key, el) => {
+    if (!/^on[A-Z]/.test(key))
+        return undefined;
+    if (key === "onDoubleClick")
+        return "dblclick";
+    if (key === "onChange") {
+        const tagName = el.tagName.toLowerCase();
+        if (tagName === "textarea")
+            return "input";
+        if (tagName === "input") {
+            const type = el.type;
+            return type === "checkbox" || type === "radio" || type === "file" ? "change" : "input";
+        }
+        if (tagName === "select")
+            return "change";
+    }
+    return key.slice(2).toLowerCase();
+};
+const isClassKey = (key) => key === "class" || key === "className";
+const isStyleKey = (key) => key === "style";
+const tokenizeClassString = (value) => value.split(/\s+/).filter((token) => token.length > 0);
+const parseStyleString = (value) => {
+    const result = {};
+    for (const part of value.split(";")) {
+        const trimmed = part.trim();
+        if (trimmed.length === 0)
+            continue;
+        const colon = trimmed.indexOf(":");
+        if (colon < 0)
+            continue;
+        const name = trimmed.slice(0, colon).trim();
+        const styleValue = trimmed.slice(colon + 1).trim();
+        if (name.length === 0)
+            continue;
+        result[name] = styleValue;
+    }
+    return result;
+};
+const computeClassSet = (value) => {
+    const result = new Set();
+    if (value == null || value === false)
+        return result;
+    if (typeof value === "string") {
+        for (const token of tokenizeClassString(value))
+            result.add(token);
+        return result;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            if (typeof item === "string" && item.length > 0)
+                result.add(item);
+        }
+        return result;
+    }
+    if (typeof value === "object") {
+        const entries = value;
+        for (const key of Object.keys(entries)) {
+            if (entries[key])
+                result.add(key);
+        }
+        return result;
+    }
+    return result;
+};
+const computeStyleMap = (value) => {
+    const result = new Map();
+    if (value == null || value === false)
+        return result;
+    if (typeof value === "string") {
+        for (const [name, styleValue] of Object.entries(parseStyleString(value))) {
+            result.set(name, styleValue);
+        }
+        return result;
+    }
+    if (typeof value === "object") {
+        const entries = value;
+        for (const key of Object.keys(entries)) {
+            const styleValue = entries[key];
+            if (styleValue == null || styleValue === false)
+                continue;
+            result.set(key, String(styleValue));
+        }
+        return result;
+    }
+    return result;
+};
+function bindProps(options) {
+    const { elementRef, renderer, destroyRef } = options;
+    let prev = {};
+    let prevElement = null;
+    const listeners = new Map();
+    const appliedClasses = new Set();
+    const appliedStyles = new Set();
+    const removeListener = (key) => {
+        const listener = listeners.get(key);
+        if (!listener)
+            return;
+        listener.dispose();
+        listeners.delete(key);
+    };
+    const removeAttribute = (el, key) => {
+        renderer.removeAttribute(el, key);
+    };
+    const removeProperty = (el, key) => {
+        renderer.setProperty(el, key, "");
+    };
+    const applyClasses = (el, nextValue) => {
+        const nextSet = computeClassSet(nextValue);
+        for (const token of appliedClasses) {
+            if (!nextSet.has(token)) {
+                renderer.removeClass(el, token);
+                appliedClasses.delete(token);
+            }
+        }
+        for (const token of nextSet) {
+            if (!appliedClasses.has(token)) {
+                renderer.addClass(el, token);
+                appliedClasses.add(token);
+            }
+        }
+    };
+    const removeAllClasses = (el) => {
+        for (const token of appliedClasses) {
+            renderer.removeClass(el, token);
+        }
+        appliedClasses.clear();
+    };
+    const styleFlags = (name) => name.startsWith("--") ? RendererStyleFlags2.DashCase : undefined;
+    const applyStyles = (el, nextValue) => {
+        const nextMap = computeStyleMap(nextValue);
+        for (const name of appliedStyles) {
+            if (!nextMap.has(name)) {
+                renderer.removeStyle(el, name, styleFlags(name));
+                appliedStyles.delete(name);
+            }
+        }
+        for (const [name, styleValue] of nextMap) {
+            renderer.setStyle(el, name, styleValue, styleFlags(name));
+            appliedStyles.add(name);
+        }
+    };
+    const removeAllStyles = (el) => {
+        for (const name of appliedStyles) {
+            renderer.removeStyle(el, name, styleFlags(name));
+        }
+        appliedStyles.clear();
+    };
+    const resetElement = (el) => {
+        for (const { dispose } of listeners.values())
+            dispose();
+        listeners.clear();
+        if (el) {
+            removeAllClasses(el);
+            removeAllStyles(el);
+        }
+        else {
+            appliedClasses.clear();
+            appliedStyles.clear();
+        }
+        prev = {};
+    };
+    effect(() => {
+        const el = elementRef.nativeElement;
+        const next = (options.props() ?? {});
+        if (el !== prevElement) {
+            resetElement(prevElement);
+            prevElement = el;
+        }
+        if (!el)
+            return;
+        for (const key of Object.keys(next)) {
+            const nextValue = next[key];
+            const prevValue = prev[key];
+            const eventName = eventNameFromHandlerKey(key, el);
+            if (eventName && typeof nextValue === "function") {
+                const listener = listeners.get(key);
+                if (prevValue === nextValue && listener?.eventName === eventName)
+                    continue;
+                removeListener(key);
+                const dispose = renderer.listen(el, eventName, nextValue);
+                listeners.set(key, { eventName, dispose });
+                continue;
+            }
+            if (eventName && listeners.has(key) && typeof nextValue !== "function") {
+                removeListener(key);
+                if (nextValue == null || nextValue === false)
+                    continue;
+            }
+            if (isClassKey(key)) {
+                if (Object.is(prevValue, nextValue))
+                    continue;
+                applyClasses(el, nextValue);
+                continue;
+            }
+            if (isStyleKey(key)) {
+                if (Object.is(prevValue, nextValue))
+                    continue;
+                applyStyles(el, nextValue);
+                continue;
+            }
+            if (isAttributeKey(key)) {
+                if (nextValue == null || nextValue === false) {
+                    if (prevValue !== undefined && prevValue !== null && prevValue !== false) {
+                        removeAttribute(el, key);
+                    }
+                    continue;
+                }
+                if (Object.is(prevValue, nextValue))
+                    continue;
+                renderer.setAttribute(el, key, String(nextValue));
+                continue;
+            }
+            if (nextValue == null) {
+                if (prevValue !== undefined && prevValue !== null) {
+                    removeProperty(el, key);
+                }
+                continue;
+            }
+            if (Object.is(prevValue, nextValue))
+                continue;
+            renderer.setProperty(el, key, nextValue);
+        }
+        for (const key of Object.keys(prev)) {
+            if (key in next)
+                continue;
+            const prevValue = prev[key];
+            const eventName = eventNameFromHandlerKey(key, el);
+            if (eventName && typeof prevValue === "function") {
+                removeListener(key);
+                continue;
+            }
+            if (isClassKey(key)) {
+                applyClasses(el, undefined);
+                continue;
+            }
+            if (isStyleKey(key)) {
+                applyStyles(el, undefined);
+                continue;
+            }
+            if (isAttributeKey(key)) {
+                removeAttribute(el, key);
+                continue;
+            }
+            removeProperty(el, key);
+        }
+        prev = { ...next };
+    });
+    destroyRef.onDestroy(() => {
+        resetElement(prevElement);
+        prevElement = null;
+    });
+}
+
+const normalizeProps = createNormalizer((v) => v);
+
+function isPlainFunction(value) {
+    return typeof value === "function";
+}
+const flush = (fn) => {
+    queueMicrotask(fn);
+};
+function useMachine(options) {
+    const destroyRef = inject(DestroyRef);
+    const machine = options.machine;
+    const latestFns = new Map();
+    const wrappers = new Map();
+    const resolveValue = (key, value) => {
+        if (!isPlainFunction(value))
+            return value;
+        latestFns.set(key, value);
+        let wrapper = wrappers.get(key);
+        if (!wrapper) {
+            wrapper = (...args) => latestFns.get(key)?.(...args);
+            wrappers.set(key, wrapper);
+        }
+        return wrapper;
+    };
+    const resolveContext = (raw) => {
+        const resolved = {};
+        for (const key of Object.keys(raw)) {
+            resolved[key] = resolveValue(key, raw[key]);
+        }
+        return resolved;
+    };
+    const initialContextRaw = options.context();
+    const initialContext = resolveContext(initialContextRaw);
+    const currentProps = signal(initialContext, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "currentProps" }] : /* istanbul ignore next */ []));
+    const scope = computed(() => {
+        const props = currentProps();
+        const getRootNode = props.getRootNode;
+        return createScope({
+            id: props.id,
+            ids: props.ids,
+            getRootNode: getRootNode ?? (() => document),
+        });
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "scope" }] : /* istanbul ignore next */ []));
+    const props = computed(() => {
+        return (machine.props?.({ props: compact(currentProps()), scope: scope() }) ?? currentProps());
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "props" }] : /* istanbul ignore next */ []));
+    const prop = ((key) => props()[key]);
+    const createBindable = (params) => {
+        const initialParams = params();
+        const initial = initialParams.value !== undefined ? initialParams.value : initialParams.defaultValue;
+        const value = signal(initial, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "value" }] : /* istanbul ignore next */ []));
+        const ref = { current: initial };
+        let defaultEffectInitialized = false;
+        let defaultHydrationChecked = false;
+        let userTouched = false;
+        effect(() => {
+            const nextParams = params();
+            const nextDefault = nextParams.defaultValue;
+            const controlled = nextParams.value !== undefined;
+            if (!defaultEffectInitialized) {
+                defaultEffectInitialized = true;
+                return;
+            }
+            if (userTouched || controlled || defaultHydrationChecked)
+                return;
+            defaultHydrationChecked = true;
+            if (nextDefault === undefined)
+                return;
+            if (!(nextParams.isEqual ?? Object.is)(untracked(value), nextDefault)) {
+                value.set(nextDefault);
+            }
+        });
+        const get = () => {
+            const controlled = params().value !== undefined;
+            const next = controlled ? params().value : value();
+            ref.current = next;
+            return next;
+        };
+        return {
+            initial,
+            ref,
+            get,
+            set(nextValue) {
+                const commit = () => {
+                    const prev = get();
+                    const next = isFunction(nextValue) ? nextValue(prev) : nextValue;
+                    if (params().debug) {
+                        console.log(`[bindable > ${params().debug}] setValue`, { next, prev });
+                    }
+                    if (params().value === undefined) {
+                        userTouched = true;
+                        value.set(next);
+                    }
+                    if (!(params().isEqual ?? Object.is)(next, prev)) {
+                        params().onChange?.(next, prev);
+                    }
+                };
+                if (params().sync)
+                    untracked(commit);
+                else
+                    commit();
+            },
+            invoke(nextValue, prevValue) {
+                params().onChange?.(nextValue, prevValue);
+            },
+            hash(valueToHash) {
+                return params().hash?.(valueToHash) ?? String(valueToHash);
+            },
+        };
+    };
+    createBindable.cleanup = (fn) => {
+        destroyRef.onDestroy(fn);
+    };
+    createBindable.ref = (defaultValue) => {
+        let value = defaultValue;
+        return {
+            get: () => value,
+            set: (next) => {
+                value = next;
+            },
+        };
+    };
+    const context = machine.context?.({
+        prop,
+        bindable: createBindable,
+        get scope() {
+            return scope();
+        },
+        flush,
+        getContext: () => ctx,
+        getComputed: () => computedValue,
+        getRefs: () => refs,
+        getEvent: () => getEvent(),
+    });
+    const ctx = {
+        get(key) {
+            return context?.[key]?.get();
+        },
+        set(key, value) {
+            context?.[key]?.set(value);
+        },
+        initial(key) {
+            return context?.[key]?.initial;
+        },
+        hash(key) {
+            const binding = context?.[key];
+            return binding?.hash(binding.get());
+        },
+    };
+    const refs = (() => {
+        const values = machine.refs?.({ prop, context: ctx }) ?? {};
+        const ref = { current: values };
+        return {
+            get(key) {
+                return ref.current[key];
+            },
+            set(key, value) {
+                ref.current[key] = value;
+            },
+        };
+    })();
+    let status = MachineStatus.NotStarted;
+    let transitionRef = null;
+    let previousEvent = null;
+    let currentEvent = { type: "" };
+    let pendingEvents = [];
+    let effects = new Map();
+    const trackedEffects = new Set();
+    const listeners = new Set();
+    let stateSignal;
+    const getEvent = () => ({
+        ...currentEvent,
+        current: () => currentEvent,
+        previous: () => previousEvent,
+    });
+    const getState = () => ({
+        ...state,
+        matches(...values) {
+            const current = state.get();
+            return values.some((value) => matchesState(current, value));
+        },
+        hasTag(tag) {
+            return hasTag(machine, state.get(), tag);
+        },
+    });
+    const notifyState = () => {
+        const next = getState();
+        stateSignal.set(next);
+        for (const listener of listeners)
+            listener(next);
+    };
+    const getParams = () => ({
+        state: getState(),
+        context: ctx,
+        event: getEvent(),
+        prop,
+        send,
+        action,
+        guard,
+        track,
+        refs,
+        computed: computedValue,
+        flush,
+        get scope() {
+            return scope();
+        },
+        choose,
+    });
+    const action = (keys) => {
+        const actionKeys = isFunction(keys) ? keys(getParams()) : keys;
+        if (!actionKeys)
+            return;
+        const fns = toArray(actionKeys).map((key) => {
+            const fn = machine.implementations?.actions?.[String(key)];
+            if (!fn)
+                warn(`[wirekyt] No implementation found for action "${JSON.stringify(key)}"`);
+            return fn;
+        });
+        for (const fn of fns) {
+            fn?.(getParams());
+        }
+    };
+    const guard = (key) => {
+        if (isFunction(key))
+            return key(getParams());
+        return machine.implementations?.guards?.[String(key)]?.(getParams());
+    };
+    const runEffects = (keys) => {
+        const effectKeys = isFunction(keys) ? keys(getParams()) : keys;
+        if (!effectKeys)
+            return undefined;
+        const fns = toArray(effectKeys).map((key) => {
+            const fn = machine.implementations?.effects?.[String(key)];
+            if (!fn)
+                warn(`[wirekyt] No implementation found for effect "${JSON.stringify(key)}"`);
+            return fn;
+        });
+        const cleanups = [];
+        for (const fn of fns) {
+            const cleanup = fn?.(getParams());
+            if (cleanup)
+                cleanups.push(cleanup);
+        }
+        return cleanups.length > 0
+            ? () => {
+                for (const cleanup of cleanups)
+                    cleanup();
+            }
+            : undefined;
+    };
+    const choose = (transitions) => {
+        return toArray(transitions).find((transition) => {
+            let result = !transition.guard;
+            if (isString(transition.guard))
+                result = !!guard(transition.guard);
+            else if (isFunction(transition.guard))
+                result = transition.guard(getParams());
+            return result;
+        });
+    };
+    const computedValue = ((key) => {
+        ensure(machine.computed, () => `[wirekyt] No computed object found on machine`);
+        const fn = machine.computed[key];
+        return fn?.({
+            context: ctx,
+            event: getEvent(),
+            prop,
+            refs,
+            get scope() {
+                return scope();
+            },
+            computed: computedValue,
+        });
+    });
+    const track = (deps, fn) => {
+        let initialized = false;
+        let previous = [];
+        const ref = effect(() => {
+            const current = deps.map((dep) => dep());
+            if (!initialized) {
+                initialized = true;
+                previous = current;
+                return;
+            }
+            if (current.some((value, index) => !isEqual(previous[index], value))) {
+                previous = current;
+                fn();
+            }
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "ref" }] : /* istanbul ignore next */ []));
+        trackedEffects.add(ref);
+    };
+    const state = createBindable(() => ({
+        defaultValue: resolveStateValue(machine, machine.initialState({ prop })),
+        onChange(nextState, prevState) {
+            const { exiting, entering } = getExitEnterStates(machine, prevState, nextState, transitionRef?.reenter);
+            for (const item of exiting) {
+                const cleanup = effects.get(item.path);
+                cleanup?.();
+                effects.delete(item.path);
+            }
+            for (const item of exiting) {
+                action(item.state?.exit);
+            }
+            action(transitionRef?.actions);
+            for (const item of entering) {
+                const cleanup = runEffects(item.state?.effects);
+                if (cleanup) {
+                    const existing = effects.get(item.path);
+                    effects.set(item.path, existing ? callAll(existing, cleanup) : cleanup);
+                }
+            }
+            if (prevState === INIT_STATE) {
+                action(machine.entry);
+                const cleanup = runEffects(machine.effects);
+                if (cleanup) {
+                    const existing = effects.get(INIT_STATE);
+                    effects.set(INIT_STATE, existing ? callAll(existing, cleanup) : cleanup);
+                }
+            }
+            for (const item of entering) {
+                action(item.state?.entry);
+            }
+            notifyState();
+        },
+    }));
+    stateSignal = signal(getState());
+    const send = (event) => {
+        if (status === MachineStatus.Stopped)
+            return;
+        if (status !== MachineStatus.Started) {
+            pendingEvents.push(event);
+            return;
+        }
+        previousEvent = currentEvent;
+        currentEvent = event;
+        const currentState = untracked(() => state.get());
+        const { transitions, source } = findTransition(machine, currentState, event.type);
+        const transition = choose(transitions);
+        if (!transition)
+            return;
+        transitionRef = transition;
+        const target = resolveStateValue(machine, transition.target ?? currentState, source);
+        if (target !== currentState) {
+            state.set(target);
+        }
+        else if (transition.reenter) {
+            state.invoke(currentState, currentState);
+        }
+        else {
+            action(transition.actions);
+        }
+    };
+    const setContext = (patch) => {
+        currentProps.update((previous) => ({ ...previous, ...patch }));
+        notifyState();
+    };
+    const stop = () => {
+        if (status === MachineStatus.Stopped)
+            return;
+        status = MachineStatus.Stopped;
+        pendingEvents = [];
+        for (const ref of trackedEffects)
+            ref.destroy();
+        trackedEffects.clear();
+        for (const cleanup of effects.values())
+            cleanup();
+        effects = new Map();
+        transitionRef = null;
+        action(machine.exit);
+        listeners.clear();
+    };
+    const service = {
+        getStatus: () => status,
+        get state() {
+            return getState();
+        },
+        context: ctx,
+        send,
+        prop,
+        get scope() {
+            return scope();
+        },
+        refs,
+        computed: computedValue,
+        get event() {
+            return getEvent();
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        setContext,
+        stop,
+    };
+    let prevRawContext = initialContextRaw;
+    let prevResolvedContext = initialContext;
+    effect(() => {
+        const nextRaw = options.context();
+        const nextKeys = new Set(Object.keys(nextRaw));
+        for (const key of Object.keys(prevRawContext)) {
+            nextKeys.add(key);
+        }
+        const patch = {};
+        let hasChanges = false;
+        const nextResolvedContext = {};
+        for (const key of nextKeys) {
+            const nextRawValue = nextRaw[key];
+            const prevRawValue = prevRawContext[key];
+            const nextResolvedValue = key in nextRaw ? resolveValue(key, nextRawValue) : undefined;
+            if (key in nextRaw) {
+                nextResolvedContext[key] = nextResolvedValue;
+            }
+            if (!Object.is(prevRawValue, nextRawValue) &&
+                !Object.is(prevResolvedContext[key], nextResolvedValue)) {
+                patch[key] = nextResolvedValue;
+                hasChanges = true;
+            }
+        }
+        if (hasChanges) {
+            service.setContext(patch);
+        }
+        prevRawContext = nextRaw;
+        prevResolvedContext = nextResolvedContext;
+    });
+    machine.watch?.(getParams());
+    afterNextRender(() => {
+        if (status === MachineStatus.Stopped)
+            return;
+        status = MachineStatus.Started;
+        state.invoke(state.initial, INIT_STATE);
+        const events = pendingEvents;
+        pendingEvents = [];
+        for (const event of events) {
+            send(event);
+        }
+    });
+    const api = computed(() => {
+        void stateSignal();
+        return options.connect(service, normalizeProps);
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "api" }] : /* istanbul ignore next */ []));
+    destroyRef.onDestroy(stop);
+    return {
+        state: stateSignal.asReadonly(),
+        send: service.send,
+        service,
+        api,
+    };
+}
+
+const ENVIRONMENT_TOKEN = new InjectionToken("WIREKIT.ENVIRONMENT_TOKEN");
+const createDefaultContext = (platformId) => ({
+    getRootNode: () => (isPlatformBrowser(platformId) ? document : undefined),
+});
+function provideEnvironment(config = {}) {
+    return {
+        provide: ENVIRONMENT_TOKEN,
+        useFactory: () => {
+            if (config.getRootNode) {
+                const getRootNode = config.getRootNode;
+                return { getRootNode };
+            }
+            const platformId = inject(PLATFORM_ID);
+            return createDefaultContext(platformId);
+        },
+    };
+}
+function injectEnvironment() {
+    const platformId = inject(PLATFORM_ID);
+    const ctx = inject(ENVIRONMENT_TOKEN, { optional: true });
+    return ctx ?? createDefaultContext(platformId);
+}
+
+const MODALITY_KEYS = new Set([
+    "Tab",
+    "ArrowUp",
+    "ArrowDown",
+    "ArrowLeft",
+    "ArrowRight",
+    "Enter",
+    "Escape",
+    " ",
+]);
+function isModalityKey(key) {
+    return MODALITY_KEYS.has(key);
+}
+class InteractionService {
+    _modality = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_modality" }] : /* istanbul ignore next */ []));
+    modality = this._modality.asReadonly();
+    isFocusVisible = computed(() => this._modality() === "keyboard", /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "isFocusVisible" }] : /* istanbul ignore next */ []));
+    constructor() {
+        const platformId = inject(PLATFORM_ID);
+        const document = inject(DOCUMENT);
+        const destroyRef = inject(DestroyRef);
+        if (!isPlatformBrowser(platformId))
+            return;
+        const onPointer = () => this._modality.set("pointer");
+        const onKey = (event) => {
+            if (isModalityKey(event.key))
+                this._modality.set("keyboard");
+        };
+        document.addEventListener("pointerdown", onPointer, true);
+        document.addEventListener("keydown", onKey, true);
+        destroyRef.onDestroy(() => {
+            document.removeEventListener("pointerdown", onPointer, true);
+            document.removeEventListener("keydown", onKey, true);
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.0", ngImport: i0, type: InteractionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.1.0", ngImport: i0, type: InteractionService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.0", ngImport: i0, type: InteractionService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+const INTERACTION_TOKEN = new InjectionToken("WIREKIT.INTERACTION_TOKEN");
+function provideInteraction() {
+    return [InteractionService, { provide: INTERACTION_TOKEN, useExisting: InteractionService }];
+}
+function injectInteraction() {
+    const ctx = inject(INTERACTION_TOKEN, { optional: true });
+    if (ctx)
+        return ctx;
+    return {
+        modality: signal(null).asReadonly(),
+        isFocusVisible: signal(false).asReadonly(),
+    };
+}
+
+const DEFAULT_LOCALE = "en-US";
+const RTL_LANG_CODES = new Set([
+    "ae",
+    "ar",
+    "arc",
+    "bcc",
+    "bqi",
+    "ckb",
+    "dv",
+    "fa",
+    "glk",
+    "he",
+    "iw",
+    "khw",
+    "ks",
+    "ku",
+    "mzn",
+    "nqo",
+    "pnb",
+    "ps",
+    "sd",
+    "ug",
+    "ur",
+    "yi",
+]);
+function getDirection(locale) {
+    const lang = locale.toLowerCase().split("-")[0] ?? "";
+    return RTL_LANG_CODES.has(lang) ? "rtl" : "ltr";
+}
+const LOCALE_TOKEN = new InjectionToken("WIREKYT.LOCALE_TOKEN");
+function provideLocale(config = {}) {
+    return {
+        provide: LOCALE_TOKEN,
+        useFactory: () => {
+            const locale = config.locale ?? DEFAULT_LOCALE;
+            const dir = config.dir ?? getDirection(locale);
+            return { locale, dir };
+        },
+    };
+}
+function injectLocale() {
+    const ctx = inject(LOCALE_TOKEN, { optional: true });
+    return ctx ?? { locale: DEFAULT_LOCALE, dir: getDirection(DEFAULT_LOCALE) };
+}
+const collatorCache = new Map();
+const dateFormatterCache = new Map();
+const filterCache = new Map();
+const MAX_CACHE_SIZE = 64;
+const stableSerialize = (value) => {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(stableSerialize).join(",")}]`;
+    const record = value;
+    return `{${Object.keys(record)
+        .sort()
+        .filter((key) => record[key] !== undefined)
+        .map((key) => `${JSON.stringify(key)}:${stableSerialize(record[key])}`)
+        .join(",")}}`;
+};
+const cacheKey = (locale, options) => `${locale}:${stableSerialize(options ?? {})}`;
+const setCached = (cache, key, value) => {
+    if (!cache.has(key) && cache.size >= MAX_CACHE_SIZE) {
+        const oldest = cache.keys().next().value;
+        if (oldest !== undefined)
+            cache.delete(oldest);
+    }
+    cache.set(key, value);
+};
+function getCollator(locale, options) {
+    const key = cacheKey(locale, options);
+    let collator = collatorCache.get(key);
+    if (!collator) {
+        collator = new Intl.Collator(locale, options);
+        setCached(collatorCache, key, collator);
+    }
+    return collator;
+}
+function getDateFormatter(locale, options) {
+    const key = cacheKey(locale, options);
+    let formatter = dateFormatterCache.get(key);
+    if (!formatter) {
+        formatter = new Intl.DateTimeFormat(locale, options);
+        setCached(dateFormatterCache, key, formatter);
+    }
+    return formatter;
+}
+function getFilter(locale, options = { sensitivity: "base" }) {
+    const normalizedOptions = { ...options, usage: "search" };
+    const key = cacheKey(locale, normalizedOptions);
+    const cached = filterCache.get(key);
+    if (cached)
+        return cached;
+    const collator = getCollator(locale, normalizedOptions);
+    const filter = {
+        contains(s, sub) {
+            if (sub.length === 0)
+                return true;
+            for (let i = 0; i + sub.length <= s.length; i++) {
+                if (collator.compare(s.slice(i, i + sub.length), sub) === 0)
+                    return true;
+            }
+            return false;
+        },
+        startsWith(s, sub) {
+            if (sub.length > s.length)
+                return false;
+            return collator.compare(s.slice(0, sub.length), sub) === 0;
+        },
+        endsWith(s, sub) {
+            if (sub.length > s.length)
+                return false;
+            return collator.compare(s.slice(s.length - sub.length), sub) === 0;
+        },
+    };
+    setCached(filterCache, key, filter);
+    return filter;
+}
+
+function createContextCarrier(options) {
+    return {
+        originInjector: options.originInjector,
+        environmentInjector: options.environmentInjector,
+        elementInjector: options.elementInjector,
+        root: options.root,
+    };
+}
+function createEmbeddedViewWithCarrier(viewContainer, template, carrier, context) {
+    return viewContainer.createEmbeddedView(template, context, {
+        injector: carrier.elementInjector,
+    });
+}
+function createComponentWithCarrier(component, carrier) {
+    return createComponent(component, {
+        environmentInjector: carrier.environmentInjector,
+        elementInjector: carrier.elementInjector,
+    });
+}
+function buildRootCarrier(options) {
+    const elementInjector = Injector.create({
+        parent: options.originInjector,
+        providers: [
+            { provide: options.rootToken, useValue: options.root },
+            ...(options.providers ?? []),
+        ],
+    });
+    return createContextCarrier({
+        originInjector: options.originInjector,
+        environmentInjector: options.environmentInjector,
+        elementInjector,
+        root: options.root,
+    });
+}
+
+const warnMixedFormAndModelBinding = (componentName) => {
+    if (!isDevMode())
+        return;
+    console.warn(`[@wyrekit/angular] ${componentName}: a form binding and [(value)] are both present on the same root. The form binding remains the source of truth.`);
+};
+
+const noopChange = (_value) => { };
+const noopTouched = () => { };
+const createCvaController = (options) => {
+    let onChange = noopChange;
+    let onTouched = noopTouched;
+    let warned = false;
+    const maybeWarn = () => {
+        if (warned)
+            return;
+        if (!options.hasExternalModelBinding())
+            return;
+        warned = true;
+        warnMixedFormAndModelBinding(options.componentName);
+    };
+    return {
+        writeValue(value) {
+            maybeWarn();
+            options.value.set(value === null ? undefined : value);
+        },
+        registerOnChange(fn) {
+            maybeWarn();
+            onChange = fn;
+        },
+        registerOnTouched(fn) {
+            onTouched = fn;
+        },
+        setDisabledState(disabled) {
+            options.setDisabled(disabled);
+        },
+        notifyValueChange(value) {
+            onChange(value);
+        },
+        markTouched() {
+            onTouched();
+        },
+    };
+};
+
+let counter = 0;
+const createId = () => {
+    counter += 1;
+    return String(counter);
+};
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { DEFAULT_LOCALE, ENVIRONMENT_TOKEN, INTERACTION_TOKEN, InteractionService, LOCALE_TOKEN, bindProps, buildRootCarrier, createComponentWithCarrier, createContextCarrier, createCvaController, createEmbeddedViewWithCarrier, createId, getCollator, getDateFormatter, getDirection, getFilter, injectEnvironment, injectInteraction, injectLocale, normalizeProps, provideEnvironment, provideInteraction, provideLocale, useMachine, warnMixedFormAndModelBinding };
+//# sourceMappingURL=wirekyt-angular.mjs.map