@ikdao/hyp 0.1.0

package/src/n.js

@@ -0,0 +1,190 @@
+import { a } from "https://cdn.jsdelivr.net/gh/ikdao/hyp@main/a.js";
+
+/* ---- Utilities -------------------------------- */
+
+function parseQuery(search) {
+  return Object.fromEntries(new URLSearchParams(search || ""));
+}
+
+function compileMatcher(pattern) {
+  const keys = [];
+  const regex = new RegExp(
+    "^" +
+      pattern
+        .replace(/\/+$/, "")
+        .replace(/:([^/]+)/g, (_, k) => {
+          keys.push(k);
+          return "([^/]+)";
+        }) +
+      "$"
+  );
+
+  return (path) => {
+    const m = path.replace(/\/+$/, "").match(regex);
+    if (!m) return null;
+    const params = {};
+    keys.forEach((k, i) => (params[k] = decodeURIComponent(m[i + 1])));
+    return params;
+  };
+}
+
+/* ---- Navigator factory (SSR-Support) -------------- */
+
+export function createNavigator({
+  url = null,
+  historyEnabled = true
+} = {}) {
+  const initialURL = url
+    ? new URL(url, "http://localhost")
+    : typeof window !== "undefined"
+      ? window.location
+      : { pathname: "/", search: "" };
+
+  /* path is ALWAYS a string */
+  const path = a(String(initialURL.pathname));
+  const query = a(parseQuery(initialURL.search));
+  const params = a({});
+
+  /* async state */
+  const loading = a(false);
+  const error = a(null);
+
+  const routes = [];
+  let beforeEach = null;
+
+  /* canonical path setter */
+  function setPath(next) {
+    if (typeof next !== "string") {
+      console.warn("[navigator] path must be string, got:", next);
+      next = String(next);
+    }
+    path.set(next);
+  }
+
+  function syncFromLocation() {
+    if (typeof window === "undefined") return;
+    setPath(window.location.pathname);
+    query.set(parseQuery(window.location.search));
+    matchRoutes();
+  }
+
+  function matchRoutes() {
+    const p = path.get();
+    for (const r of routes) {
+      const res = r.match(p);
+      if (res) {
+        params.set(res);
+        return r;
+      }
+    }
+    params.set({});
+    return null;
+  }
+
+  async function navigate(to, replace = false) {
+    const from = path.get();
+    const target = String(to);
+
+    /* Guards */
+    if (beforeEach) {
+      const result = await beforeEach(target, from);
+      if (result === false) return;
+      if (typeof result === "string") {
+        return navigate(result, true);
+      }
+    }
+
+    if (typeof window !== "undefined" && historyEnabled) {
+      if (replace) history.replaceState(null, "", target);
+      else history.pushState(null, "", target);
+    }
+
+    setPath(target);
+    matchRoutes();
+  }
+
+  if (typeof window !== "undefined" && historyEnabled) {
+    window.addEventListener("popstate", syncFromLocation);
+  }
+
+  /* -------- 4: async resolve ---------------- */
+
+  async function resolveAsync() {
+    loading.set(true);
+    error.set(null);
+
+    try {
+      const r = matchRoutes();
+      if (!r) {
+        loading.set(false);
+        return null;
+      }
+
+      let view = r.view;
+
+      // Allow lazy / async route views
+      if (typeof view === "function") {
+        const res = view();
+        view = res instanceof Promise ? await res : res;
+      }
+
+      loading.set(false);
+      return view;
+    } catch (err) {
+      error.set(err);
+      loading.set(false);
+      throw err;
+    }
+  }
+
+  return {
+    /* Reactive state */
+    path,
+    query,
+    params,
+    loading,
+    error,
+
+    /* Routing table */
+    route(pattern, view) {
+      routes.push({
+        pattern,
+        view,
+        match: compileMatcher(pattern)
+      });
+    },
+
+    /* Navigation */
+    go(to) {
+      return navigate(to, false);
+    },
+
+    replace(to) {
+      return navigate(to, true);
+    },
+
+    back() {
+      if (typeof window !== "undefined") history.back();
+    },
+
+    forward() {
+      if (typeof window !== "undefined") history.forward();
+    },
+
+    /* Guards */
+    beforeEach(fn) {
+      beforeEach = fn;
+    },
+
+    /* Sync resolve (unchanged) */
+    resolve() {
+      const r = matchRoutes();
+      return r ? r.view : null;
+    },
+
+    /* Async resolve (NEW) */
+    resolveAsync
+  };
+}
+
+export const n = createNavigator();

package/src/o.js

@@ -0,0 +1,75 @@
+// ORGANISER (o)    
+// Structural Layer — Organise Organs, keep identities and map
+// Self License - 01SL
+// HYP UI Framework 
+// Author: Hemang Tewari
+
+export const o = (function () {
+    const organs = new Map();
+    let nextEi = 1;
+
+    function newEi() { return "ei_" + nextEi++; }
+
+    return {
+        create(hi, body) {
+            const ei = newEi();
+            organs.set(ei, {
+                hi,
+                body,
+                ctx: new Map(),
+                mounted: true,
+                lifecycles: {
+                    willMount: [], didMount: [],
+                    willUpdate: [], didUpdate: [],
+                    willUnmount: [], didUnmount: []
+                },
+                effects: new Set()
+            });
+            return ei;
+        },
+        addLifecycle(ei, phase, fn) {
+            const inst = organs.get(ei);
+            if (inst) inst.lifecycles[phase].push(fn);
+        },
+        runLifecycle(ei, phase, bodyRef) {
+            const inst = organs.get(ei);
+            if (!inst) return;
+            const list = inst.lifecycles[phase];
+            if (!list) return;
+            for (const fn of list)
+                s.add(() => fn(bodyRef), ei);
+        },
+        addEffect(ei, clear) {
+            const inst = organs.get(ei);
+            if (inst) inst.effects.add({ clear });
+        },
+        destroy(ei, { runLifecycle = true } = {}) {
+            const inst = organs.get(ei);
+            if (!inst) return;
+
+            inst.mounted = false;
+
+            if (runLifecycle) {
+                this.runLifecycle(ei, "willUnmount");
+                s.add(() => this.runLifecycle(ei, "didUnmount"), ei);
+            }
+
+            if (inst.effects) {
+                for (const ef of inst.effects)
+                    if (typeof ef.clear === "function") {
+                        try { ef.clear(); }
+                        catch (err) { console.error("Effect clear error:", err); }
+                    }
+            }
+            organs.delete(ei);
+            s.clear(ei);
+        },
+        get(ei) { return organs.get(ei); },
+        has(ei) { return organs.has(ei); },
+        isAlive(ei) {
+            const inst = organs.get(ei);
+            return inst ? inst.mounted : false;
+        },
+        all() { return organs; }
+    };
+})();

package/src/r.js

@@ -0,0 +1,16 @@
+// Reactor r()/Derived Act dA()
+// Self License - 01SL
+// HYP UI Framework 
+// Author: Hemang Tewari
+
+export const r = (compute) => {
+    const sig = a();
+    const recompute = () => {
+        tr = recompute;
+        const val = compute();
+        tr = null;
+        sig.set(val);
+    };
+    recompute();
+    return sig;
+};

package/src/s.js

@@ -0,0 +1,39 @@
+// SCHEDULER (s)    
+// Temporal Layer — queues & runs tasks efficiently    
+// Self License - 01SL
+// HYP UI Framework 
+// Author: Hemang Tewari
+
+export const s = (function () {
+    const left = new Set();
+    let flushing = false;
+
+    function flush() {
+        flushing = false;
+        const tasks = Array.from(left);
+        left.clear();
+        for (const task of tasks) {
+            try { task.fn(); }
+            catch (err) { console.error("Scheduler task error:", err); }
+        }
+    }
+
+    return {
+        add(fn, ei) {
+            if (ei && !o.isAlive(ei)) return;
+            left.add({ fn, ei });
+            if (!flushing) {
+                queueMicrotask(flush);
+                flushing = true;
+            }
+        },
+
+        flush() { flush(); },
+
+        clear(ei) {
+            for (const task of [...left]) {
+                if (task.ei === ei) left.delete(task);
+            }
+        }
+    };
+})();

package/src/sA.js

@@ -0,0 +1,52 @@
+
+// Side Act sA()
+export const sA = (effect, depsFn = null, explicitEI = null) => {
+    const ei = explicitEI ?? e.currentEI(); // fallback to currentEI
+    if (!ei) return;
+    const inst = o.get(ei);
+    if (!inst) return;
+
+    if (!inst.ctx.has('sA-hooks')) inst.ctx.set('sA-hooks', new Map());
+    const hk = inst.ctx.get('sA-hooks');
+    const key = `sA-${hk.size}`;
+
+    const isEqualDeps = (a, b) => {
+        if (!a || !b || a.length !== b.length) return false;
+        for (let i = 0; i < a.length; i++) {
+            if (!Object.is(a[i], b[i])) return false;
+        }
+        return true;
+    };
+    let unsubscribers = [];
+    const run = () => {
+        tr = run;
+        const deps = depsFn ? depsFn() : [];
+        tr = null;
+
+        const prev = hk.get(key);
+        const changed = !prev || !isEqualDeps(deps, prev.deps);
+
+        if (changed) {
+            // cleanup previous effect and Actor subscriptions
+            prev?.clear?.();
+            unsubscribers.forEach(u => u());
+            unsubscribers = [];
+
+            // run effect
+            const clear = effect();
+            hk.set(key, { deps, clear });
+            if (clear) inst.effects.add({ clear });
+
+            // auto re-run if any Actor deps change
+            for (const d of deps) {
+                if (d instanceof Actor) {
+                    const unsub = d.subscribe(() => s.add(run, ei));
+                    unsubscribers.push(unsub);
+                    if (ei) o.addEffect(ei, unsub);
+                }
+            }
+        }
+    };
+    run();
+    s.add(run, ei);
+};