@thyn/core 0.0.322 → 0.0.323

package/dist/element.d.ts

@@ -0,0 +1,18 @@
+export declare function mount(app: any, parent: any): void;
+export declare function collectEffect(effectFn: any): void;
+export declare function createReactiveTextNode(v: any): any;
+export declare function component(name: any, props?: any): any;
+export declare function fixedComponent(name: any, props?: any): any;
+export declare function setAttribute(el: any, key: any, val: any): any;
+export declare function setProperty(el: any, key: any, val: any): any;
+export declare function setReactiveAttribute(el: any, key: any, val: any): any;
+export declare function setReactiveProperty(el: any, key: any, val: any): any;
+export declare function addChildren(e: any, children: any): any;
+export declare function markAsReactive(el: any): any;
+export declare function addEffect(el: any, ef: any): any;
+export declare function show(props: any): (Element | Comment) & {
+    $fx?: any;
+};
+export declare function terminalList(props: any): DocumentFragment;
+export declare function list(props: any, terminal?: boolean): DocumentFragment;
+export declare function isolatedTerminalList(props: any): DocumentFragment;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { addChildren, addEffect, component, createReactiveTextNode, fixedComponent, isolatedTerminalList, list, markAsReactive, mount, setAttribute, setProperty, setReactiveAttribute, setReactiveProperty, show, terminalList } from "./element.js";
+export { $effect, $signal, staticEffect } from "./signals.js";

package/dist/index.js

@@ -0,0 +1,2 @@
+export { addChildren, addEffect, component, createReactiveTextNode, fixedComponent, isolatedTerminalList, list, markAsReactive, mount, setAttribute, setProperty, setReactiveAttribute, setReactiveProperty, show, terminalList } from "./element.js";
+export { $effect, $signal, staticEffect } from "./signals.js";

package/dist/router.d.ts

@@ -0,0 +1,16 @@
+export declare const router: {
+    path: import("./signals.js").Signal<string>;
+    param: (name: string) => string | undefined;
+};
+interface Route {
+    path: string;
+    component: () => Node;
+}
+export declare function Router({ routes }: {
+    routes: Route[];
+}): any;
+export declare function Link({ slot, to }: {
+    slot: any;
+    to: any;
+}): HTMLAnchorElement;
+export {};

package/dist/router.js

@@ -0,0 +1,66 @@
+import { component, show } from "./element.js";
+import { $signal, staticEffect } from "./signals.js";
+const params = $signal({});
+export const router = {
+    path: $signal(location.pathname),
+    param: (name) => params()[name],
+};
+export function Router({ routes }) {
+    const current = $signal(null);
+    const compiledRoutes = routes.map(route => {
+        const compiledRoute = {
+            path: null,
+            raw: route,
+            names: [],
+            component: route.component,
+        };
+        compiledRoute.path = new RegExp(`^${route.path.replace(/\/:([^/]+)/g, (_, name) => {
+            compiledRoute.names.push(name);
+            return '/([^/]+)';
+        })}$`);
+        return compiledRoute;
+    });
+    staticEffect(() => {
+        const pn = router.path();
+        if (pn !== location.pathname) {
+            history.pushState({}, "", pn);
+        }
+        const ps = {};
+        let rt = null;
+        for (const route of compiledRoutes) {
+            const match = pn.match(route.path);
+            if (!match)
+                continue;
+            for (let i = 0; i < route.names.length; i++) {
+                const name = route.names[i];
+                ps[name] = decodeURIComponent(match[i + 1]);
+            }
+            rt = route;
+            break;
+        }
+        ;
+        current(rt);
+        params(ps);
+    });
+    return component(show, compiledRoutes.map((r) => ({
+        if: () => r === current(),
+        then: () => component(r.component),
+    })));
+}
+export function Link({ slot, to }) {
+    const a = document.createElement("a");
+    a.href = to;
+    for (const ch of slot) {
+        a.appendChild(ch);
+    }
+    a.onclick = (e) => {
+        if (!e.defaultPrevented &&
+            e.button === 0 &&
+            !(e.metaKey || e.ctrlKey || e.shiftKey || e.altKey)) {
+            e.preventDefault();
+            history.pushState({}, "", to);
+            router.path(to);
+        }
+    };
+    return a;
+}

package/dist/signals.d.ts

@@ -0,0 +1,10 @@
+export interface Signal<T> {
+    (): T;
+    (newValue: T): void;
+    (updater: (prev: T) => T): void;
+}
+export declare function $signal<T>(initialValue: T): Signal<T>;
+export declare function $effect(fn: (() => (() => void) | void) & any): any;
+export declare function staticEffect(fn: (() => (() => void) | void) & any): any;
+export declare function uncollectedStaticEffect(fn: (() => (() => void) | void) & any): any;
+export declare function cleanup(ef: any): void;

package/dist/signals.js

@@ -0,0 +1,101 @@
+import { collectEffect } from "./element.js";
+let currentEffect;
+let isBatching;
+const pendingEffects = [];
+function scheduleEffect(effectFn) {
+    pendingEffects.push(effectFn);
+    if (!isBatching) {
+        isBatching = true;
+        queueMicrotask(() => {
+            for (const ef of pendingEffects) {
+                if (ef.dyn) {
+                    cleanup(ef);
+                    const prev = currentEffect;
+                    currentEffect = ef;
+                    runEffectFn(ef);
+                    currentEffect = prev;
+                }
+                else {
+                    ef();
+                }
+            }
+            pendingEffects.length = 0;
+            isBatching = false;
+        });
+    }
+}
+export function $signal(initialValue) {
+    let value = initialValue;
+    const subs = new Set();
+    return function (newValue) {
+        if (!arguments.length) {
+            if (currentEffect) {
+                subs.add(currentEffect);
+                const td = currentEffect.td;
+                currentEffect.td = !td ? subs : (Array.isArray(td) ? (td.push(subs), td) : [td, subs]);
+            }
+            return value;
+        }
+        newValue = typeof newValue === "function" ? newValue(value) : newValue;
+        if (newValue !== value) {
+            value = newValue;
+            subs.forEach(scheduleEffect);
+        }
+    };
+}
+function runEffectFn(ef) {
+    const td = ef();
+    if (td) {
+        if (ef.td) {
+            if (Array.isArray(ef.td)) {
+                ef.td.push(td);
+            }
+            else {
+                ef.td = [ef.td, td];
+            }
+        }
+        else {
+            ef.td = td;
+        }
+    }
+}
+export function $effect(fn) {
+    const prev = currentEffect;
+    currentEffect = fn;
+    fn.dyn = true;
+    runEffectFn(fn);
+    currentEffect = prev;
+    collectEffect(fn);
+    return fn;
+}
+export function staticEffect(fn) {
+    fn.td = null;
+    const prev = currentEffect;
+    currentEffect = fn;
+    fn();
+    currentEffect = prev;
+    collectEffect(fn);
+    return fn;
+}
+export function uncollectedStaticEffect(fn) {
+    fn.td = null;
+    const prev = currentEffect;
+    currentEffect = fn;
+    fn();
+    currentEffect = prev;
+    return fn;
+}
+export function cleanup(ef) {
+    if (!ef.td)
+        return;
+    if (ef.td.delete) {
+        ef.td.delete(ef);
+    }
+    else if (typeof ef.td === "function") {
+        ef.td();
+    }
+    else {
+        for (const f of ef.td)
+            typeof f === "function" ? f() : f.delete(ef);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thyn/core",
-  "version": "0.0.322",
+  "version": "0.0.323",
   "scripts": {
     "build": "tsc",
     "pub": "tsc && npm version patch -f && npm -f publish --access=public",