@stacksjs/stx 0.2.95 → 0.2.96

package/dist/reactivity.js

@@ -1,2 +1,559 @@
-// @bun
-import{ci as a,di as b,ei as c,fi as d,gi as e,hi as f,ii as g,ji as h,ki as i,li as j,mi as k,ni as l,oi as m,pi as n,qi as o,ri as p,si as q,ti as r,ui as s,vi as t,wi as u}from"./chunk-7b6s3g65.js";import"./chunk-xv34zbp4.js";export{i as watchMultiple,j as watchEffect,h as watch,s as updateInstance,t as unmountInstance,a as setCurrentInstance,q as runHooks,e as ref,f as reactive,n as onUpdated,p as onUnmounted,l as onMounted,m as onBeforeUpdate,o as onBeforeUnmount,k as onBeforeMount,r as mountInstance,b as getCurrentInstance,u as generateClientRuntime,d as createScope,e as createRef,f as createReactive,g as createComputed,c as createComponentInstance,g as computed};
+let currentInstance = null, currentEffect = null;
+function structuralEqual(a, b, seen = new WeakSet) {
+  if (Object.is(a, b))
+    return !0;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null)
+    return !1;
+  if (seen.has(a))
+    return !0;
+  seen.add(a);
+  if (a instanceof Date && b instanceof Date)
+    return a.getTime() === b.getTime();
+  if (a instanceof RegExp && b instanceof RegExp)
+    return a.source === b.source && a.flags === b.flags;
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b) || a.length !== b.length)
+      return !1;
+    for (let i = 0;i < a.length; i++)
+      if (!structuralEqual(a[i], b[i], seen))
+        return !1;
+    return !0;
+  }
+  if (Array.isArray(b))
+    return !1;
+  if (a instanceof Map) {
+    if (!(b instanceof Map) || a.size !== b.size)
+      return !1;
+    for (const [k, v] of a)
+      if (!b.has(k) || !structuralEqual(v, b.get(k), seen))
+        return !1;
+    return !0;
+  }
+  if (b instanceof Map)
+    return !1;
+  if (a instanceof Set) {
+    if (!(b instanceof Set) || a.size !== b.size)
+      return !1;
+    for (const v of a)
+      if (!b.has(v))
+        return !1;
+    return !0;
+  }
+  if (b instanceof Set)
+    return !1;
+  const aKeys = Object.keys(a), bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length)
+    return !1;
+  for (const k of aKeys) {
+    if (!Object.prototype.hasOwnProperty.call(b, k))
+      return !1;
+    if (!structuralEqual(a[k], b[k], seen))
+      return !1;
+  }
+  return !0;
+}
+export function setCurrentInstance(instance) {
+  currentInstance = instance;
+}
+export function getCurrentInstance() {
+  return currentInstance;
+}
+export function createComponentInstance() {
+  return {
+    isMounted: !1,
+    isUnmounted: !1,
+    hooks: {
+      beforeMount: [],
+      mounted: [],
+      beforeUpdate: [],
+      updated: [],
+      beforeUnmount: [],
+      unmounted: []
+    },
+    effects: [],
+    scope: createScope()
+  };
+}
+export function createScope() {
+  return {
+    refs: new Map,
+    effects: new Set,
+    cleanups: []
+  };
+}
+export function ref(initialValue) {
+  const subscribers = new Set, effectSubscribers = new Set;
+  let value = initialValue;
+  const id = Symbol("ref"), refObj = {
+    get value() {
+      if (currentEffect)
+        effectSubscribers.add(currentEffect);
+      return value;
+    },
+    set value(newValue) {
+      if (!Object.is(newValue, value)) {
+        const oldValue = value;
+        value = newValue;
+        for (const callback of subscribers)
+          callback(newValue, oldValue);
+        for (const effect of effectSubscribers)
+          effect();
+      }
+    },
+    subscribe(callback) {
+      subscribers.add(callback);
+      return () => {
+        subscribers.delete(callback);
+      };
+    }
+  };
+  if (currentInstance)
+    currentInstance.scope.refs.set(id, refObj);
+  return refObj;
+}
+const reactiveMap = new WeakMap;
+export function reactive(target) {
+  const existing = reactiveMap.get(target);
+  if (existing)
+    return existing;
+  const subscribers = new Map, notify = (key) => {
+    const subs = subscribers.get(key);
+    if (subs)
+      for (const callback of [...subs])
+        callback();
+  }, subscribe = (key, callback) => {
+    if (!subscribers.has(key))
+      subscribers.set(key, new Set);
+    subscribers.get(key).add(callback);
+    return () => {
+      subscribers.get(key)?.delete(callback);
+    };
+  }, proxy = new Proxy(target, {
+    get(obj, prop, receiver) {
+      const value = Reflect.get(obj, prop, receiver);
+      if (currentEffect)
+        subscribe(prop, currentEffect);
+      if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+        const proto = Object.getPrototypeOf(value);
+        if (proto === Object.prototype || proto === null)
+          return reactive(value);
+      }
+      return value;
+    },
+    set(obj, prop, value, receiver) {
+      const oldValue = Reflect.get(obj, prop, receiver), result = Reflect.set(obj, prop, value, receiver);
+      if (!Object.is(value, oldValue))
+        notify(prop);
+      return result;
+    },
+    deleteProperty(obj, prop) {
+      const result = Reflect.deleteProperty(obj, prop);
+      notify(prop);
+      return result;
+    }
+  });
+  reactiveMap.set(target, proxy);
+  return proxy;
+}
+export function computed(getter) {
+  let cachedValue, dirty = !0;
+  const subscribers = new Set, effectSubscribers = new Set, markDirty = () => {
+    dirty = !0;
+    update();
+  }, update = () => {
+    if (dirty) {
+      const oldValue = cachedValue, prevEffect = currentEffect;
+      currentEffect = markDirty;
+      cachedValue = getter();
+      currentEffect = prevEffect;
+      dirty = !1;
+      if (!Object.is(cachedValue, oldValue)) {
+        for (const callback of subscribers)
+          callback(cachedValue, oldValue);
+        for (const effect of effectSubscribers)
+          effect();
+      }
+    }
+  }, prevEffect = currentEffect;
+  currentEffect = markDirty;
+  cachedValue = getter();
+  dirty = !1;
+  currentEffect = prevEffect;
+  return {
+    get value() {
+      if (currentEffect)
+        effectSubscribers.add(currentEffect);
+      update();
+      return cachedValue;
+    },
+    set value(_) {
+      console.warn("[stx] Computed properties are readonly");
+    },
+    subscribe(callback) {
+      subscribers.add(callback);
+      return () => {
+        subscribers.delete(callback);
+      };
+    }
+  };
+}
+export function watch(source, callback, options = {}) {
+  const { immediate = !1, deep = !1, flush = "post" } = options;
+  let oldValue, cleanup, stopped = !1;
+  const job = () => {
+    if (stopped)
+      return;
+    const newValue = getValueTracking();
+    if ((deep ? !structuralEqual(newValue, oldValue) : !Object.is(newValue, oldValue)) || immediate) {
+      callback(newValue, oldValue);
+      if (deep && newValue !== null && typeof newValue === "object")
+        try {
+          oldValue = structuredClone(newValue);
+        } catch {
+          oldValue = newValue;
+        }
+      else
+        oldValue = newValue;
+    }
+  }, scheduler = (fn) => {
+    if (flush === "sync")
+      fn();
+    else if (flush === "pre")
+      Promise.resolve().then(fn);
+    else
+      requestAnimationFrame(() => {
+        requestAnimationFrame(fn);
+      });
+  };
+  let scheduled = !1;
+  const onChange = () => {
+    if (stopped || scheduled)
+      return;
+    scheduled = !0;
+    scheduler(() => {
+      scheduled = !1;
+      job();
+    });
+  }, getValueTracking = () => {
+    if (typeof source === "function") {
+      const prevEffect = currentEffect;
+      currentEffect = onChange;
+      try {
+        return source();
+      } finally {
+        currentEffect = prevEffect;
+      }
+    }
+    return source.value;
+  };
+  if (typeof source !== "function") {
+    const unsubscribe = source.subscribe(() => {
+      scheduler(job);
+    });
+    cleanup = () => {
+      stopped = !0;
+      unsubscribe();
+    };
+  } else
+    cleanup = () => {
+      stopped = !0;
+    };
+  oldValue = getValueTracking();
+  if (immediate)
+    scheduler(job);
+  if (currentInstance)
+    currentInstance.scope.cleanups.push(() => cleanup?.());
+  return () => cleanup?.();
+}
+export function watchMultiple(sources, callback, options = {}) {
+  const cleanups = [];
+  let oldValues = sources.map((s) => s.value);
+  for (const source of sources) {
+    const unwatch = source.subscribe(() => {
+      const newValues = sources.map((s) => s.value);
+      callback(newValues, oldValues);
+      oldValues = [...newValues];
+    });
+    cleanups.push(unwatch);
+  }
+  if (options.immediate) {
+    const newValues = sources.map((s) => s.value);
+    callback(newValues, oldValues);
+  }
+  return () => {
+    for (const cleanup of cleanups)
+      cleanup();
+  };
+}
+export function watchEffect(effect) {
+  let cleanup, stopped = !1;
+  const run = () => {
+    if (stopped)
+      return;
+    if (cleanup)
+      cleanup();
+    const prevEffect = currentEffect;
+    currentEffect = run;
+    cleanup = effect();
+    currentEffect = prevEffect;
+  };
+  run();
+  if (currentInstance)
+    currentInstance.scope.cleanups.push(() => {
+      stopped = !0;
+      if (cleanup)
+        cleanup();
+    });
+  return () => {
+    stopped = !0;
+    if (cleanup)
+      cleanup();
+  };
+}
+export function onBeforeMount(callback) {
+  if (currentInstance)
+    currentInstance.hooks.beforeMount.push(callback);
+  else
+    console.warn("[stx] onBeforeMount called outside of component setup");
+}
+export function onMounted(callback) {
+  if (currentInstance)
+    currentInstance.hooks.mounted.push(callback);
+  else
+    console.warn("[stx] onMounted called outside of component setup");
+}
+export function onBeforeUpdate(callback) {
+  if (currentInstance)
+    currentInstance.hooks.beforeUpdate.push(callback);
+  else
+    console.warn("[stx] onBeforeUpdate called outside of component setup");
+}
+export function onUpdated(callback) {
+  if (currentInstance)
+    currentInstance.hooks.updated.push(callback);
+  else
+    console.warn("[stx] onUpdated called outside of component setup");
+}
+export function onBeforeUnmount(callback) {
+  if (currentInstance)
+    currentInstance.hooks.beforeUnmount.push(callback);
+  else
+    console.warn("[stx] onBeforeUnmount called outside of component setup");
+}
+export function onUnmounted(callback) {
+  if (currentInstance)
+    currentInstance.hooks.unmounted.push(callback);
+  else
+    console.warn("[stx] onUnmounted called outside of component setup");
+}
+export async function runHooks(instance, hookName) {
+  const hooks = instance.hooks[hookName];
+  for (const hook of hooks)
+    await hook();
+}
+export async function mountInstance(instance) {
+  await runHooks(instance, "beforeMount");
+  instance.isMounted = !0;
+  await runHooks(instance, "mounted");
+}
+export async function updateInstance(instance) {
+  if (!instance.isMounted || instance.isUnmounted)
+    return;
+  await runHooks(instance, "beforeUpdate");
+  await runHooks(instance, "updated");
+}
+export async function unmountInstance(instance) {
+  if (instance.isUnmounted)
+    return;
+  await runHooks(instance, "beforeUnmount");
+  for (const cleanup of instance.scope.cleanups)
+    cleanup();
+  instance.isUnmounted = !0;
+  await runHooks(instance, "unmounted");
+}
+export function generateClientRuntime() {
+  return `
+<script data-stx-client-runtime>
+(function() {
+  'use strict';
+
+  // Reactive ref implementation
+  function ref(initialValue) {
+    const subscribers = new Set();
+    let value = initialValue;
+
+    return {
+      get value() { return value; },
+      set value(newValue) {
+        if (!Object.is(newValue, value)) {
+          const oldValue = value;
+          value = newValue;
+          subscribers.forEach(cb => cb(newValue, oldValue));
+        }
+      },
+      subscribe(callback) {
+        subscribers.add(callback);
+        return () => subscribers.delete(callback);
+      }
+    };
+  }
+
+  // Reactive object implementation
+  function reactive(target) {
+    const subscribers = new Map();
+
+    const notify = (key) => {
+      const subs = subscribers.get(key);
+      if (subs) subs.forEach(cb => cb());
+    };
+
+    return new Proxy(target, {
+      get(obj, prop, receiver) {
+        const value = Reflect.get(obj, prop, receiver);
+        if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+          return reactive(value);
+        }
+        return value;
+      },
+      set(obj, prop, value, receiver) {
+        const oldValue = Reflect.get(obj, prop, receiver);
+        const result = Reflect.set(obj, prop, value, receiver);
+        if (!Object.is(value, oldValue)) notify(prop);
+        return result;
+      }
+    });
+  }
+
+  // Computed implementation
+  function computed(getter) {
+    let cachedValue;
+    let dirty = true;
+    const subscribers = new Set();
+
+    return {
+      get value() {
+        if (dirty) {
+          cachedValue = getter();
+          dirty = false;
+        }
+        return cachedValue;
+      },
+      subscribe(callback) {
+        subscribers.add(callback);
+        return () => subscribers.delete(callback);
+      }
+    };
+  }
+
+  // Watch implementation
+  function watch(source, callback, options = {}) {
+    const { immediate = false } = options;
+    let oldValue = typeof source === 'function' ? source() : source.value;
+
+    const unsubscribe = (typeof source === 'function' ? { subscribe: () => {} } : source)
+      .subscribe((newValue) => {
+        callback(newValue, oldValue);
+        oldValue = newValue;
+      });
+
+    if (immediate) {
+      callback(oldValue, undefined);
+    }
+
+    return unsubscribe;
+  }
+
+  // Lifecycle hooks
+  const lifecycleHooks = {
+    beforeMount: [],
+    mounted: [],
+    beforeUpdate: [],
+    updated: [],
+    beforeUnmount: [],
+    unmounted: []
+  };
+
+  function onBeforeMount(cb) { lifecycleHooks.beforeMount.push(cb); }
+  function onMounted(cb) { lifecycleHooks.mounted.push(cb); }
+  function onBeforeUpdate(cb) { lifecycleHooks.beforeUpdate.push(cb); }
+  function onUpdated(cb) { lifecycleHooks.updated.push(cb); }
+  function onBeforeUnmount(cb) { lifecycleHooks.beforeUnmount.push(cb); }
+  function onUnmounted(cb) { lifecycleHooks.unmounted.push(cb); }
+
+  // Run lifecycle hooks
+  async function runHooks(hookName) {
+    for (const hook of lifecycleHooks[hookName]) {
+      await hook();
+    }
+  }
+
+  // Initialize on DOM ready
+  document.addEventListener('DOMContentLoaded', async () => {
+    await runHooks('beforeMount');
+    await runHooks('mounted');
+  });
+
+  // Cleanup on page unload
+  window.addEventListener('beforeunload', async () => {
+    await runHooks('beforeUnmount');
+    await runHooks('unmounted');
+  });
+
+  // Internal state (hidden from developers)
+  var __stores = {};
+  var __routeParams = {};
+  var __middlewareState = {};
+
+  // provide() \u2014 share values across components (like Vue's provide/inject)
+  function provide(name, value) {
+    window[name] = value;
+  }
+
+  // Expose globally for <script client> blocks
+  window.stx = {
+    // Reactivity
+    ref,
+    reactive,
+    computed,
+    watch,
+    onBeforeMount,
+    onMounted,
+    onBeforeUpdate,
+    onUpdated,
+    onBeforeUnmount,
+    onUnmounted,
+    provide,
+
+    // Store access (clean API - no window.* exposure)
+    useStore: function(name) { return __stores[name] || null; },
+    hasStore: function(name) { return name in __stores; },
+    getStoreNames: function() { return Object.keys(__stores); },
+
+    // Route params (clean API)
+    useRouteParams: function() { return __routeParams; },
+    useRouteParam: function(name) { return __routeParams[name]; },
+
+    // Middleware state (clean API)
+    useMiddlewareState: function() { return __middlewareState; },
+
+    // Internal setters (used by framework, not exposed in docs)
+    // eslint-disable-next-line pickier/no-unused-vars
+    setRouteParams: function(params) { __routeParams = params || {}; },
+    // eslint-disable-next-line pickier/no-unused-vars
+    setMiddlewareState: function(state) { __middlewareState = state || {}; },
+    registerStore: function(name, store) { __stores[name] = store; },
+
+    // SSR detection
+    isClient: function() { return true; },
+    isServer: function() { return false; }
+  };
+  window.provide = provide;
+})();
+</script>`;
+}
+
+export {
+  ref as createRef,
+  reactive as createReactive,
+  computed as createComputed
+};

package/dist/release.js

@@ -1,2 +1 @@
-// @bun
-import{xi as a}from"./chunk-wvf31nzs.js";import"./chunk-xv34zbp4.js";export{a as gitHash};
+export const gitHash = "f9c3713";