effect-start 0.19.0 → 0.20.1

package/dist/datastar/attributes/style.js

@@ -0,0 +1,56 @@
+import { attribute } from "../engine.js";
+import { effect } from "../engine.js";
+import { kebab } from "../utils.js";
+attribute({
+    name: "style",
+    requirement: {
+        value: "must",
+    },
+    returnsValue: true,
+    apply({ key, el, rx }) {
+        const { style } = el;
+        const initialStyles = new Map();
+        const apply = (prop, value) => {
+            const initial = initialStyles.get(prop);
+            if (!value && value !== 0) {
+                initial !== undefined
+                    && (initial
+                        ? style.setProperty(prop, initial)
+                        : style.removeProperty(prop));
+            }
+            else {
+                initial === undefined
+                    && initialStyles.set(prop, style.getPropertyValue(prop));
+                style.setProperty(prop, String(value));
+            }
+        };
+        const update = () => {
+            observer.disconnect();
+            if (key) {
+                apply(key, rx());
+            }
+            else {
+                const styles = rx();
+                for (const [prop, initial] of initialStyles) {
+                    prop in styles
+                        || (initial
+                            ? style.setProperty(prop, initial)
+                            : style.removeProperty(prop));
+                }
+                for (const prop in styles) {
+                    apply(kebab(prop), styles[prop]);
+                }
+            }
+            observer.observe(el, { attributeFilter: ["style"] });
+        };
+        const observer = new MutationObserver(update);
+        const cleanup = effect(update);
+        return () => {
+            observer.disconnect();
+            cleanup();
+            for (const [prop, initial] of initialStyles) {
+                initial ? style.setProperty(prop, initial) : style.removeProperty(prop);
+            }
+        };
+    },
+});

package/dist/datastar/attributes/text.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/datastar/attributes/text.js

@@ -0,0 +1,27 @@
+import { attribute } from "../engine.js";
+import { effect } from "../engine.js";
+attribute({
+    name: "text",
+    requirement: {
+        key: "denied",
+        value: "must",
+    },
+    returnsValue: true,
+    apply({ el, rx }) {
+        const update = () => {
+            observer.disconnect();
+            el.textContent = `${rx()}`;
+            observer.observe(el, {
+                childList: true,
+                characterData: true,
+                subtree: true,
+            });
+        };
+        const observer = new MutationObserver(update);
+        const cleanup = effect(update);
+        return () => {
+            observer.disconnect();
+            cleanup();
+        };
+    },
+});

package/dist/datastar/engine.d.ts

@@ -0,0 +1,156 @@
+export declare const DSP: string;
+export declare const DSS: string;
+export declare const DATASTAR_FETCH_EVENT = "datastar-fetch";
+export declare const DATASTAR_SIGNAL_PATCH_EVENT = "datastar-signal-patch";
+/*********
+ * types.ts
+ *********/
+export type JSONPatch = Record<string, any> & {
+    length?: never;
+};
+export type Paths = [string, any][];
+export type DatastarFetchEvent = {
+    type: string;
+    el: HTMLOrSVG;
+    argsRaw: Record<string, string>;
+};
+export type CustomEventMap = {
+    [DATASTAR_SIGNAL_PATCH_EVENT]: CustomEvent<JSONPatch>;
+};
+export type WatcherFn<K extends keyof CustomEventMap> = (this: Document, ev: CustomEventMap[K]) => void;
+export type ErrorFn = (name: string, ctx?: Record<string, any>) => void;
+export type ActionContext = {
+    el: HTMLOrSVG;
+    evt?: Event;
+    error: ErrorFn;
+    cleanups: Map<string, () => void>;
+};
+export type RequirementType = "allowed" | "must" | "denied" | "exclusive";
+export type Requirement = RequirementType | {
+    key: Exclude<RequirementType, "exclusive">;
+    value?: Exclude<RequirementType, "exclusive">;
+} | {
+    key?: Exclude<RequirementType, "exclusive">;
+    value: Exclude<RequirementType, "exclusive">;
+};
+type Rx<B extends boolean> = (...args: any[]) => B extends true ? unknown : void;
+type ReqField<R, K extends "key" | "value", Return> = R extends "must" | {
+    [P in K]: "must";
+} ? Return : R extends "denied" | {
+    [P in K]: "denied";
+} ? undefined : R extends "allowed" | {
+    [P in K]: "allowed";
+} | (K extends keyof R ? never : R) ? Return | undefined : never;
+type ReqFields<R extends Requirement, B extends boolean> = R extends "exclusive" ? {
+    key: string;
+    value: undefined;
+    rx: undefined;
+} | {
+    key: undefined;
+    value: string;
+    rx: Rx<B>;
+} : {
+    key: ReqField<R, "key", string>;
+    value: ReqField<R, "value", string>;
+    rx: ReqField<R, "value", Rx<B>>;
+};
+export type AttributeContext<R extends Requirement = Requirement, RxReturn extends boolean = boolean> = {
+    el: HTMLOrSVG;
+    mods: Modifiers;
+    rawKey: string;
+    evt?: Event;
+    error: ErrorFn;
+    loadedPluginNames: {
+        actions: Readonly<Set<string>>;
+        attributes: Readonly<Set<string>>;
+    };
+} & ReqFields<R, RxReturn>;
+export type AttributePlugin<R extends Requirement = Requirement, RxReturn extends boolean = boolean> = {
+    name: string;
+    apply: (ctx: AttributeContext<R, RxReturn>) => void | (() => void);
+    requirement?: R;
+    returnsValue?: RxReturn;
+    argNames?: string[];
+};
+export type WatcherContext = {
+    error: ErrorFn;
+};
+export type WatcherPlugin = {
+    name: string;
+    apply: (ctx: WatcherContext, args: Record<string, string | undefined>) => void;
+};
+export type ActionPlugins = Record<string, ActionPlugin>;
+export type ActionPlugin<T = any> = {
+    name: string;
+    apply: (ctx: ActionContext, ...args: any[]) => T;
+};
+export type MergePatchArgs = {
+    ifMissing?: boolean;
+};
+export type HTMLOrSVG = HTMLElement | SVGElement | MathMLElement;
+export type Modifiers = Map<string, Set<string>>;
+export type EventCallbackHandler = (...args: any[]) => void;
+export type SignalFilter = RegExp;
+export type SignalFilterOptions = {
+    include?: RegExp | string;
+    exclude?: RegExp | string;
+};
+export type Signal<T> = {
+    (): T;
+    (value: T): boolean;
+};
+export type Computed<T> = () => T;
+export type Effect = () => void;
+/*********
+ * signals.ts
+ *********/
+interface ReactiveNode {
+    deps_?: Link;
+    depsTail_?: Link;
+    subs_?: Link;
+    subsTail_?: Link;
+    flags_: ReactiveFlags;
+}
+interface Link {
+    version_: number;
+    dep_: ReactiveNode;
+    sub_: ReactiveNode;
+    prevSub_?: Link;
+    nextSub_?: Link;
+    prevDep_?: Link;
+    nextDep_?: Link;
+}
+declare const ReactiveFlags: {
+    readonly None: 0;
+    readonly Mutable: number;
+    readonly Watching: number;
+    readonly RecursedCheck: number;
+    readonly Recursed: number;
+    readonly Dirty: number;
+    readonly Pending: number;
+};
+type ReactiveFlags = typeof ReactiveFlags[keyof typeof ReactiveFlags];
+export declare const beginBatch: () => void;
+export declare const endBatch: () => void;
+export declare const startPeeking: (sub?: ReactiveNode) => void;
+export declare const stopPeeking: () => void;
+export declare const signal: <T>(initialValue?: T) => Signal<T>;
+export declare const computed: <T>(getter: (previousValue?: T) => T) => Computed<T>;
+export declare const effect: (fn: () => void) => Effect;
+export declare const getPath: <T = any>(path: string) => T | undefined;
+export declare const mergePatch: (patch: JSONPatch, { ifMissing }?: MergePatchArgs) => void;
+export declare const mergePaths: (paths: Paths, options?: MergePatchArgs) => void;
+export declare const filtered: ({ include, exclude }?: SignalFilterOptions, obj?: JSONPatch) => Record<string, any>;
+export declare const root: Record<string, any>;
+export declare const actions: Record<string, (ctx: ActionContext, ...args: any[]) => any>;
+export declare const attribute: <R extends Requirement, B extends boolean>(plugin: AttributePlugin<R, B>) => void;
+export declare const action: <T>(plugin: ActionPlugin<T>) => void;
+export declare const watcher: (plugin: WatcherPlugin) => void;
+export declare const parseAttributeKey: (rawKey: string) => {
+    pluginName: string;
+    key: string | undefined;
+    mods: Modifiers;
+};
+export declare const isDocumentObserverActive: () => boolean;
+export declare const apply: (root?: HTMLOrSVG | ShadowRoot, observeRoot?: boolean) => void;
+export {};