@supersoniks/concorde 4.9.96 → 4.9.98-visual-stack.0

package/dist/js/core/decorators/api.js

@@ -0,0 +1,806 @@
+import HTML from "@supersoniks/concorde/core/utils/HTML";
+import API from "@supersoniks/concorde/core/utils/api";
+import { setSubscribable } from "./subscriber/common";
+import { extractDynamicDependencies, resolveDynamicPath, } from "./subscriber/dynamicPath";
+import { getDynamicWatchKeys, observeDynamicProperty, } from "./subscriber/dynamicPropertyWatch";
+import { getPublisherFromPath } from "./subscriber/publisherPath";
+function asSearchableHost(component) {
+    if (component instanceof HTMLElement || component instanceof ShadowRoot) {
+        return component;
+    }
+    return null;
+}
+function readApiConfigurationFromPublisher(publisher) {
+    if (!publisher || typeof publisher.get !== "function")
+        return null;
+    const raw = publisher.get();
+    if (!raw || typeof raw !== "object")
+        return null;
+    if (!("serviceURL" in raw))
+        return null;
+    return raw;
+}
+function resolveScopedConfiguration(component) {
+    const host = asSearchableHost(component);
+    if (!host)
+        return null;
+    return HTML.getApiConfiguration(host);
+}
+function isScopedConfigurationReady(config) {
+    return typeof config?.serviceURL === "string" && config.serviceURL.length > 0;
+}
+/** Attributs scope dont la présence peut déclencher un GET différé (Lit → minuscules). */
+const SCOPE_WATCH_ATTRIBUTES = [
+    "serviceURL",
+    "serviceurl",
+    "token",
+    "credentials",
+    "tokenProvider",
+    "tokenprovider",
+    "userName",
+    "username",
+    "password",
+    "eventsApiToken",
+    "eventsapitoken",
+];
+function isLitHost(component) {
+    return (component instanceof HTMLElement &&
+        typeof component.updateComplete !== "undefined");
+}
+/**
+ * Regroupe plusieurs déclencheurs synchrones (mutations `onInternalMutation`,
+ * `rebindAll`, etc.) en un seul appel par frame — même principe que
+ * `dynamicPropertyWatch.ts` (`scheduleObservedPropertyChanges`).
+ */
+function createAnimationFrameCoalescedRunner(run) {
+    let frameId = null;
+    let pending = [];
+    return () => {
+        const promise = new Promise((resolve, reject) => {
+            pending.push({ resolve, reject });
+        });
+        if (frameId !== null)
+            return promise;
+        frameId = requestAnimationFrame(() => {
+            frameId = null;
+            const current = pending;
+            pending = [];
+            void run().then((value) => current.forEach(({ resolve }) => resolve(value)), (reason) => current.forEach(({ reject }) => reject(reason)));
+        });
+        return promise;
+    };
+}
+function scheduleAfterHostReady(component, callback) {
+    if (isLitHost(component)) {
+        let cancelled = false;
+        void component.updateComplete.then(() => {
+            if (!cancelled)
+                callback();
+        });
+        return () => {
+            cancelled = true;
+        };
+    }
+    // HTMLElement classique : config ancêtre déjà lisible ; sinon watchScopedConfiguration.
+    callback();
+    return () => { };
+}
+/**
+ * Attend que la config scope soit lisible (attributs DOM ou propriétés Lit reflect).
+ */
+function watchScopedConfiguration(component, onReady) {
+    const host = asSearchableHost(component);
+    if (!host)
+        return () => { };
+    let settled = false;
+    const tryNotify = () => {
+        if (settled)
+            return;
+        if (!isScopedConfigurationReady(resolveScopedConfiguration(component))) {
+            return;
+        }
+        settled = true;
+        onReady();
+    };
+    tryNotify();
+    if (settled)
+        return () => { };
+    const cleanups = [];
+    const rafId = requestAnimationFrame(() => tryNotify());
+    cleanups.push(() => cancelAnimationFrame(rafId));
+    queueMicrotask(() => tryNotify());
+    const observer = new MutationObserver(() => tryNotify());
+    let node = host;
+    while (node) {
+        if (node instanceof Element) {
+            observer.observe(node, {
+                attributes: true,
+                attributeFilter: [...SCOPE_WATCH_ATTRIBUTES],
+            });
+        }
+        node = (node.parentNode ||
+            node.host);
+    }
+    cleanups.push(() => observer.disconnect());
+    return () => {
+        settled = true;
+        cleanups.forEach((cleanup) => cleanup());
+    };
+}
+/**
+ * Handle interne des décorateurs API.
+ *
+ * Le WeakMap cible l'instance connectée, pas la valeur de payload : une
+ * opération peut donc être relancée avant son premier résultat et reste
+ * indépendante d'une affectation manuelle de la propriété décorée.
+ */
+class ApiOperationController {
+    constructor() {
+        this.bindings = new WeakMap();
+    }
+    bind(component, run) {
+        const binding = { run };
+        let componentBindings = this.bindings.get(component);
+        if (!componentBindings) {
+            componentBindings = new Set();
+            this.bindings.set(component, componentBindings);
+        }
+        componentBindings.add(binding);
+        return () => {
+            const currentBindings = this.bindings.get(component);
+            if (!currentBindings)
+                return;
+            currentBindings.delete(binding);
+            if (currentBindings.size === 0) {
+                this.bindings.delete(component);
+            }
+        };
+    }
+    run(component) {
+        const runs = [...(this.bindings.get(component) ?? [])].map(({ run }) => run());
+        if (runs.length === 0)
+            return Promise.resolve(undefined);
+        if (runs.length === 1)
+            return runs[0];
+        return Promise.all(runs).then(() => undefined);
+    }
+}
+let nextApiHandlerPropertyId = 0;
+function isPromiseLike(value) {
+    return (value !== null &&
+        (typeof value === "object" || typeof value === "function") &&
+        typeof value.then === "function");
+}
+function createApiMethodActionDecorator(action, options) {
+    const when = options?.when ?? "after";
+    return (_target, _propertyKey, descriptor) => {
+        const original = descriptor.value;
+        if (!original)
+            return;
+        const wrapped = function (...args) {
+            if (when === "before") {
+                return action(this).then(() => original.apply(this, args));
+            }
+            const result = original.apply(this, args);
+            if (isPromiseLike(result)) {
+                return result.then((value) => {
+                    return action(this).then(() => value);
+                });
+            }
+            return action(this).then(() => result);
+        };
+        descriptor.value = wrapped;
+    };
+}
+export function refetch(handle, options) {
+    return createApiMethodActionDecorator((component) => handle.refetch(component), options);
+}
+export function send(handle, options) {
+    return createApiMethodActionDecorator((component) => handle.send(component), options);
+}
+function detachConfigPublisher(state) {
+    if (state.configPublisher && state.configMutationHandler) {
+        state.configPublisher.offInternalMutation(state.configMutationHandler);
+    }
+    state.configPublisher = null;
+    state.configMutationHandler = null;
+}
+export function get(endpoint, configurationKeyOrOptions, maybeOptions) {
+    const pathTemplate = endpoint.path;
+    const configurationKey = isGetOptions(configurationKeyOrOptions)
+        ? undefined
+        : configurationKeyOrOptions;
+    const options = isGetOptions(configurationKeyOrOptions)
+        ? configurationKeyOrOptions
+        : maybeOptions;
+    const pathOptions = {
+        skipEmptyPlaceholder: options?.skipEmptyPlaceholder,
+    };
+    const configurationKeyPath = configurationKey?.path;
+    const triggerKeyPath = options?.triggerKey?.path;
+    const endpointDynamicDependencies = extractDynamicDependencies(pathTemplate);
+    const configKeyDynamicDependencies = configurationKeyPath
+        ? extractDynamicDependencies(configurationKeyPath)
+        : [];
+    const triggerKeyDynamicDependencies = triggerKeyPath
+        ? extractDynamicDependencies(triggerKeyPath)
+        : [];
+    const mergedDynamicDependencies = [
+        ...new Set([
+            ...endpointDynamicDependencies,
+            ...configKeyDynamicDependencies,
+            ...triggerKeyDynamicDependencies,
+        ]),
+    ];
+    const isDynamicPath = endpointDynamicDependencies.length > 0;
+    const usesPublisherConfig = Boolean(configurationKeyPath);
+    const refetchEveryMs = options?.refetchEveryMs ?? 0;
+    const operationController = new ApiOperationController();
+    const resultHandlers = new WeakMap();
+    const decoratedTargets = new WeakSet();
+    const operationPropertyKeys = new WeakMap();
+    let handlerPropertyKey;
+    const decorator = function (target, propertyKey, descriptor) {
+        if (descriptor) {
+            const handler = descriptor.value;
+            if (!handler)
+                return;
+            decorator.registerResultHandler(target, (component, payload) => handler.call(component, payload));
+            return;
+        }
+        if (!target)
+            return;
+        if (decoratedTargets.has(target)) {
+            operationPropertyKeys.get(target)?.add(propertyKey);
+            return;
+        }
+        decoratedTargets.add(target);
+        operationPropertyKeys.set(target, new Set([propertyKey]));
+        setSubscribable(target);
+        const stateKey = `__get_state_${propertyKey}`;
+        target.__onConnected__((component) => {
+            const comp = component;
+            let state = comp[stateKey];
+            if (!state) {
+                state = {
+                    cleanupWatchers: [],
+                    cleanupOperation: null,
+                    requestGeneration: 0,
+                    configPublisher: null,
+                    configMutationHandler: null,
+                    scopeWatchCleanup: null,
+                    triggerPublisher: null,
+                    triggerInvalidateHandler: null,
+                    refetchTimeoutId: null,
+                    refetchEveryMs,
+                };
+                comp[stateKey] = state;
+            }
+            state.cleanupOperation?.();
+            state.cleanupOperation = null;
+            state.cleanupWatchers.forEach((cleanup) => cleanup());
+            state.cleanupWatchers = [];
+            state.requestGeneration++;
+            state.refetchEveryMs = refetchEveryMs;
+            clearRefetch(state);
+            const scheduleRefetch = () => {
+                clearRefetch(state);
+                if (!state.refetchEveryMs || state.refetchEveryMs <= 0)
+                    return;
+                state.refetchTimeoutId = setTimeout(() => {
+                    state.refetchTimeoutId = null;
+                    void runFetch().catch(() => { });
+                }, state.refetchEveryMs);
+            };
+            const assignPayload = (payload) => {
+                operationPropertyKeys.get(target)?.forEach((key) => {
+                    comp[key] = payload;
+                });
+            };
+            const runFetch = async () => {
+                const resolution = isDynamicPath
+                    ? resolveDynamicPath(component, pathTemplate, pathOptions)
+                    : { ready: true, path: pathTemplate };
+                if (!resolution.ready || !resolution.path) {
+                    assignPayload(undefined);
+                    scheduleRefetch();
+                    return undefined;
+                }
+                let config = null;
+                if (usesPublisherConfig && configurationKeyPath) {
+                    const configRes = resolveDynamicPath(component, configurationKeyPath, pathOptions);
+                    if (!configRes.ready || !configRes.path) {
+                        assignPayload(undefined);
+                        scheduleRefetch();
+                        return undefined;
+                    }
+                    const configPublisher = getPublisherFromPath(configRes.path);
+                    config = readApiConfigurationFromPublisher(configPublisher);
+                }
+                else {
+                    config = resolveScopedConfiguration(component);
+                }
+                if (!isScopedConfigurationReady(config)) {
+                    if (!usesPublisherConfig && !state.scopeWatchCleanup) {
+                        const scopeWatch = watchScopedConfiguration(component, scheduleFetchAndIgnoreErrors);
+                        state.scopeWatchCleanup = scopeWatch;
+                        state.cleanupWatchers.push(() => {
+                            scopeWatch();
+                            state.scopeWatchCleanup = null;
+                        });
+                    }
+                    scheduleRefetch();
+                    return undefined;
+                }
+                const generation = ++state.requestGeneration;
+                const api = new API(config);
+                const payload = await api.getDetailed(resolution.path);
+                if (generation !== state.requestGeneration)
+                    return payload;
+                operationPropertyKeys.get(target)?.forEach((key) => {
+                    comp[key] = payload;
+                });
+                scheduleRefetch();
+                resultHandlers
+                    .get(target)
+                    ?.forEach((handler) => handler(component, payload));
+                return payload;
+            };
+            const scheduleFetch = createAnimationFrameCoalescedRunner(runFetch);
+            const scheduleFetchAndIgnoreErrors = () => {
+                void scheduleFetch().catch(() => { });
+            };
+            state.cleanupOperation = operationController.bind(component, scheduleFetch);
+            const rebindTriggerPublisher = () => {
+                detachTriggerPublisher(state);
+                if (!triggerKeyPath)
+                    return;
+                const triggerResolution = resolveDynamicPath(component, triggerKeyPath, pathOptions);
+                if (!triggerResolution.ready || !triggerResolution.path) {
+                    return;
+                }
+                const publisher = getPublisherFromPath(triggerResolution.path);
+                if (!publisher)
+                    return;
+                const invalidateHandler = scheduleFetchAndIgnoreErrors;
+                publisher.onInvalidate(invalidateHandler);
+                state.triggerPublisher = publisher;
+                state.triggerInvalidateHandler = invalidateHandler;
+            };
+            const rebindPublisherConfig = () => {
+                if (!usesPublisherConfig || !configurationKeyPath)
+                    return;
+                detachConfigPublisher(state);
+                const configRes = resolveDynamicPath(component, configurationKeyPath, pathOptions);
+                if (!configRes.ready || !configRes.path) {
+                    assignPayload(undefined);
+                    return;
+                }
+                const publisher = getPublisherFromPath(configRes.path);
+                if (!publisher) {
+                    assignPayload(undefined);
+                    return;
+                }
+                const mutationHandler = scheduleFetchAndIgnoreErrors;
+                publisher.onInternalMutation(mutationHandler);
+                state.configPublisher = publisher;
+                state.configMutationHandler = mutationHandler;
+            };
+            const rebindAll = () => {
+                rebindTriggerPublisher();
+                rebindPublisherConfig();
+                if (!usesPublisherConfig) {
+                    scheduleFetchAndIgnoreErrors();
+                }
+            };
+            if (usesPublisherConfig || triggerKeyDynamicDependencies.length) {
+                for (const dependency of mergedDynamicDependencies) {
+                    const unsubscribe = observeDynamicProperty(getDynamicWatchKeys.watcherStore, getDynamicWatchKeys.hooked, component, dependency, () => rebindAll());
+                    state.cleanupWatchers.push(unsubscribe);
+                }
+                rebindAll();
+            }
+            else {
+                const startScopedFetch = () => {
+                    if (isDynamicPath) {
+                        for (const dependency of endpointDynamicDependencies) {
+                            const unsubscribe = observeDynamicProperty(getDynamicWatchKeys.watcherStore, getDynamicWatchKeys.hooked, component, dependency, scheduleFetchAndIgnoreErrors);
+                            state.cleanupWatchers.push(unsubscribe);
+                        }
+                    }
+                    rebindTriggerPublisher();
+                    void runFetch().catch(() => { });
+                };
+                state.cleanupWatchers.push(scheduleAfterHostReady(component, startScopedFetch));
+            }
+        });
+        target.__onDisconnected__((component) => {
+            const comp = component;
+            const state = comp[stateKey];
+            if (!state)
+                return;
+            state.cleanupOperation?.();
+            state.cleanupOperation = null;
+            detachConfigPublisher(state);
+            detachTriggerPublisher(state);
+            clearRefetch(state);
+            state.cleanupWatchers.forEach((cleanup) => cleanup());
+            state.cleanupWatchers = [];
+            state.requestGeneration++;
+            operationPropertyKeys.get(target)?.forEach((key) => {
+                comp[key] = undefined;
+            });
+        });
+    };
+    decorator.refetch = (component) => {
+        return operationController.run(component);
+    };
+    decorator.registerResultHandler = (target, handler) => {
+        let handlers = resultHandlers.get(target);
+        if (!handlers) {
+            handlers = new Set();
+            resultHandlers.set(target, handlers);
+        }
+        handlers.add(handler);
+        if (!decoratedTargets.has(target)) {
+            handlerPropertyKey ??= `__get_handler_${nextApiHandlerPropertyId++}`;
+            decorator(target, handlerPropertyKey);
+        }
+    };
+    return decorator;
+}
+function isGetOptions(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    return ("skipEmptyPlaceholder" in value ||
+        "refetchEveryMs" in value ||
+        "triggerKey" in value);
+}
+function isApiSendOptions(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    return ("refetchEveryMs" in value ||
+        "skipIfBodyMissing" in value ||
+        "autoPostOnBodyMutation" in value ||
+        "skipEmptyPlaceholder" in value ||
+        "triggerKey" in value);
+}
+function detachBodyPublisher(state) {
+    if (state.bodyPublisher && state.bodyMutationHandler) {
+        state.bodyPublisher.offInternalMutation(state.bodyMutationHandler);
+    }
+    state.bodyPublisher = null;
+    state.bodyMutationHandler = null;
+}
+function detachTriggerPublisher(state) {
+    if (state.triggerPublisher && state.triggerInvalidateHandler) {
+        state.triggerPublisher.offInvalidate(state.triggerInvalidateHandler);
+    }
+    state.triggerPublisher = null;
+    state.triggerInvalidateHandler = null;
+}
+function clearRefetch(state) {
+    if (state.refetchTimeoutId) {
+        clearTimeout(state.refetchTimeoutId);
+        state.refetchTimeoutId = null;
+    }
+}
+function readBodyFromPublisher(publisher) {
+    if (!publisher || typeof publisher.get !== "function")
+        return undefined;
+    return publisher.get();
+}
+function createApiSendDecorator(method, callDetailed) {
+    return function (endpoint, bodyKey, configurationKeyOrOptions, maybeOptions) {
+        const pathTemplate = endpoint.path;
+        const bodyKeyPath = bodyKey.path;
+        const configurationKey = isApiSendOptions(configurationKeyOrOptions)
+            ? undefined
+            : configurationKeyOrOptions;
+        const options = isApiSendOptions(configurationKeyOrOptions)
+            ? configurationKeyOrOptions
+            : maybeOptions;
+        const configurationKeyPath = configurationKey?.path;
+        const triggerKeyPath = options?.triggerKey?.path;
+        const endpointDynamicDependencies = extractDynamicDependencies(pathTemplate);
+        const bodyKeyDynamicDependencies = extractDynamicDependencies(bodyKeyPath);
+        const configKeyDynamicDependencies = configurationKeyPath
+            ? extractDynamicDependencies(configurationKeyPath)
+            : [];
+        const triggerKeyDynamicDependencies = triggerKeyPath
+            ? extractDynamicDependencies(triggerKeyPath)
+            : [];
+        const mergedDynamicDependencies = [
+            ...new Set([
+                ...endpointDynamicDependencies,
+                ...bodyKeyDynamicDependencies,
+                ...configKeyDynamicDependencies,
+                ...triggerKeyDynamicDependencies,
+            ]),
+        ];
+        const isDynamicPath = endpointDynamicDependencies.length > 0;
+        const usesPublisherConfig = Boolean(configurationKeyPath);
+        const refetchEveryMs = options?.refetchEveryMs ?? 0;
+        const skipIfBodyMissing = options?.skipIfBodyMissing ?? true;
+        const autoPostOnBodyMutation = options?.autoPostOnBodyMutation ?? true;
+        const pathOptions = {
+            skipEmptyPlaceholder: options?.skipEmptyPlaceholder,
+        };
+        const stateKeyPrefix = `__${method.toLowerCase()}_state_`;
+        const operationController = new ApiOperationController();
+        const resultHandlers = new WeakMap();
+        const decoratedTargets = new WeakSet();
+        const operationPropertyKeys = new WeakMap();
+        let handlerPropertyKey;
+        const decorator = function (target, propertyKey, descriptor) {
+            if (descriptor) {
+                const handler = descriptor.value;
+                if (!handler)
+                    return;
+                decorator.registerResultHandler(target, (component, payload) => handler.call(component, payload));
+                return;
+            }
+            if (!target)
+                return;
+            if (decoratedTargets.has(target)) {
+                operationPropertyKeys.get(target)?.add(propertyKey);
+                return;
+            }
+            decoratedTargets.add(target);
+            operationPropertyKeys.set(target, new Set([propertyKey]));
+            setSubscribable(target);
+            const stateKey = `${stateKeyPrefix}${propertyKey}`;
+            target.__onConnected__((component) => {
+                const comp = component;
+                let state = comp[stateKey];
+                if (!state) {
+                    state = {
+                        cleanupWatchers: [],
+                        cleanupOperation: null,
+                        requestGeneration: 0,
+                        configPublisher: null,
+                        configMutationHandler: null,
+                        scopeWatchCleanup: null,
+                        bodyPublisher: null,
+                        bodyMutationHandler: null,
+                        triggerPublisher: null,
+                        triggerInvalidateHandler: null,
+                        refetchTimeoutId: null,
+                        refetchEveryMs,
+                        skipIfBodyMissing,
+                        autoPostOnBodyMutation,
+                    };
+                    comp[stateKey] = state;
+                }
+                state.cleanupOperation?.();
+                state.cleanupOperation = null;
+                state.cleanupWatchers.forEach((cleanup) => cleanup());
+                state.cleanupWatchers = [];
+                state.requestGeneration++;
+                state.refetchEveryMs = refetchEveryMs;
+                state.skipIfBodyMissing = skipIfBodyMissing;
+                state.autoPostOnBodyMutation = autoPostOnBodyMutation;
+                clearRefetch(state);
+                const scheduleRefetch = () => {
+                    clearRefetch(state);
+                    if (!state.refetchEveryMs || state.refetchEveryMs <= 0)
+                        return;
+                    state.refetchTimeoutId = setTimeout(() => {
+                        state.refetchTimeoutId = null;
+                        void runSend().catch(() => { });
+                    }, state.refetchEveryMs);
+                };
+                const assignPayload = (payload) => {
+                    operationPropertyKeys.get(target)?.forEach((key) => {
+                        comp[key] = payload;
+                    });
+                };
+                const runSend = async () => {
+                    const resolution = isDynamicPath
+                        ? resolveDynamicPath(component, pathTemplate, pathOptions)
+                        : { ready: true, path: pathTemplate };
+                    if (!resolution.ready || !resolution.path) {
+                        assignPayload(undefined);
+                        scheduleRefetch();
+                        return undefined;
+                    }
+                    const bodyResolution = resolveDynamicPath(component, bodyKeyPath, pathOptions);
+                    if (!bodyResolution.ready || !bodyResolution.path) {
+                        assignPayload(undefined);
+                        scheduleRefetch();
+                        return undefined;
+                    }
+                    const bodyPublisher = getPublisherFromPath(bodyResolution.path);
+                    const body = readBodyFromPublisher(bodyPublisher);
+                    if (state.skipIfBodyMissing &&
+                        (body === null || body === undefined)) {
+                        scheduleRefetch();
+                        return undefined;
+                    }
+                    let config = null;
+                    if (usesPublisherConfig && configurationKeyPath) {
+                        const configRes = resolveDynamicPath(component, configurationKeyPath, pathOptions);
+                        if (!configRes.ready || !configRes.path) {
+                            assignPayload(undefined);
+                            scheduleRefetch();
+                            return undefined;
+                        }
+                        const configPublisher = getPublisherFromPath(configRes.path);
+                        config = readApiConfigurationFromPublisher(configPublisher);
+                    }
+                    else {
+                        config = resolveScopedConfiguration(component);
+                    }
+                    if (!isScopedConfigurationReady(config)) {
+                        if (!usesPublisherConfig && !state.scopeWatchCleanup) {
+                            const scopeWatch = watchScopedConfiguration(component, scheduleSendAndIgnoreErrors);
+                            state.scopeWatchCleanup = scopeWatch;
+                            state.cleanupWatchers.push(() => {
+                                scopeWatch();
+                                state.scopeWatchCleanup = null;
+                            });
+                        }
+                        scheduleRefetch();
+                        return undefined;
+                    }
+                    const generation = ++state.requestGeneration;
+                    const api = new API(config);
+                    let payload;
+                    try {
+                        payload = await callDetailed(api, resolution.path, body);
+                    }
+                    catch (error) {
+                        if (generation === state.requestGeneration) {
+                            resultHandlers
+                                .get(target)
+                                ?.forEach((handler) => handler(component, undefined));
+                        }
+                        throw error;
+                    }
+                    if (generation !== state.requestGeneration)
+                        return payload;
+                    assignPayload(payload);
+                    scheduleRefetch();
+                    resultHandlers
+                        .get(target)
+                        ?.forEach((handler) => handler(component, payload));
+                    return payload;
+                };
+                const scheduleSend = createAnimationFrameCoalescedRunner(runSend);
+                const scheduleSendAndIgnoreErrors = () => {
+                    void scheduleSend().catch(() => { });
+                };
+                state.cleanupOperation = operationController.bind(component, scheduleSend);
+                const rebindBodyPublisher = () => {
+                    detachBodyPublisher(state);
+                    if (!state.autoPostOnBodyMutation) {
+                        return;
+                    }
+                    const bodyResolution = resolveDynamicPath(component, bodyKeyPath, pathOptions);
+                    if (!bodyResolution.ready || !bodyResolution.path) {
+                        return;
+                    }
+                    const publisher = getPublisherFromPath(bodyResolution.path);
+                    if (!publisher)
+                        return;
+                    const mutationHandler = scheduleSendAndIgnoreErrors;
+                    publisher.onInternalMutation(mutationHandler);
+                    state.bodyPublisher = publisher;
+                    state.bodyMutationHandler = mutationHandler;
+                };
+                const rebindTriggerPublisher = () => {
+                    detachTriggerPublisher(state);
+                    if (!triggerKeyPath)
+                        return;
+                    const triggerResolution = resolveDynamicPath(component, triggerKeyPath, pathOptions);
+                    if (!triggerResolution.ready || !triggerResolution.path) {
+                        return;
+                    }
+                    const publisher = getPublisherFromPath(triggerResolution.path);
+                    if (!publisher)
+                        return;
+                    const invalidateHandler = scheduleSendAndIgnoreErrors;
+                    publisher.onInvalidate(invalidateHandler);
+                    state.triggerPublisher = publisher;
+                    state.triggerInvalidateHandler = invalidateHandler;
+                };
+                const rebindPublisherConfig = () => {
+                    if (!usesPublisherConfig || !configurationKeyPath)
+                        return;
+                    detachConfigPublisher(state);
+                    const configRes = resolveDynamicPath(component, configurationKeyPath, pathOptions);
+                    if (!configRes.ready || !configRes.path) {
+                        assignPayload(undefined);
+                        return;
+                    }
+                    const publisher = getPublisherFromPath(configRes.path);
+                    if (!publisher) {
+                        assignPayload(undefined);
+                        return;
+                    }
+                    const mutationHandler = scheduleSendAndIgnoreErrors;
+                    publisher.onInternalMutation(mutationHandler);
+                    state.configPublisher = publisher;
+                    state.configMutationHandler = mutationHandler;
+                };
+                const rebindAll = () => {
+                    rebindBodyPublisher();
+                    rebindTriggerPublisher();
+                    rebindPublisherConfig();
+                    if (state.autoPostOnBodyMutation) {
+                        scheduleSendAndIgnoreErrors();
+                    }
+                };
+                if (usesPublisherConfig ||
+                    bodyKeyDynamicDependencies.length ||
+                    triggerKeyDynamicDependencies.length) {
+                    for (const dependency of mergedDynamicDependencies) {
+                        const unsubscribe = observeDynamicProperty(getDynamicWatchKeys.watcherStore, getDynamicWatchKeys.hooked, component, dependency, () => rebindAll());
+                        state.cleanupWatchers.push(unsubscribe);
+                    }
+                    rebindAll();
+                }
+                else {
+                    const startScopedSend = () => {
+                        if (isDynamicPath) {
+                            for (const dependency of endpointDynamicDependencies) {
+                                const unsubscribe = observeDynamicProperty(getDynamicWatchKeys.watcherStore, getDynamicWatchKeys.hooked, component, dependency, scheduleSendAndIgnoreErrors);
+                                state.cleanupWatchers.push(unsubscribe);
+                            }
+                        }
+                        rebindBodyPublisher();
+                        rebindTriggerPublisher();
+                        if (state.autoPostOnBodyMutation) {
+                            scheduleSendAndIgnoreErrors();
+                        }
+                    };
+                    state.cleanupWatchers.push(scheduleAfterHostReady(component, startScopedSend));
+                }
+            });
+            target.__onDisconnected__((component) => {
+                const comp = component;
+                const state = comp[stateKey];
+                if (!state)
+                    return;
+                state.cleanupOperation?.();
+                state.cleanupOperation = null;
+                detachConfigPublisher(state);
+                detachBodyPublisher(state);
+                detachTriggerPublisher(state);
+                clearRefetch(state);
+                state.cleanupWatchers.forEach((cleanup) => cleanup());
+                state.cleanupWatchers = [];
+                state.requestGeneration++;
+                operationPropertyKeys.get(target)?.forEach((key) => {
+                    comp[key] = undefined;
+                });
+            });
+        };
+        decorator.send = (component) => {
+            return operationController.run(component);
+        };
+        decorator.registerResultHandler = (target, handler) => {
+            let handlers = resultHandlers.get(target);
+            if (!handlers) {
+                handlers = new Set();
+                resultHandlers.set(target, handlers);
+            }
+            handlers.add(handler);
+            if (!decoratedTargets.has(target)) {
+                handlerPropertyKey ??= `__${method.toLowerCase()}_handler_${nextApiHandlerPropertyId++}`;
+                decorator(target, handlerPropertyKey);
+            }
+        };
+        return decorator;
+    };
+}
+export function post(endpoint, bodyKey, configurationKeyOrOptions, maybeOptions) {
+    return createApiSendDecorator("POST", (api, path, body) => api.postDetailed(path, body))(endpoint, bodyKey, configurationKeyOrOptions, maybeOptions);
+}
+export function put(endpoint, bodyKey, configurationKeyOrOptions, maybeOptions) {
+    return createApiSendDecorator("PUT", (api, path, body) => api.putDetailed(path, body))(endpoint, bodyKey, configurationKeyOrOptions, maybeOptions);
+}
+export function patch(endpoint, bodyKey, configurationKeyOrOptions, maybeOptions) {
+    return createApiSendDecorator("PATCH", (api, path, body) => api.patchDetailed(path, body))(endpoint, bodyKey, configurationKeyOrOptions, maybeOptions);
+}
+//# sourceMappingURL=api.js.map