@stacksjs/stx 0.2.95 → 0.2.96

package/dist/composition-api.js

@@ -1,2 +1,190 @@
-// @bun
-import{$q as i,Tq as a,Uq as b,Vq as c,Wq as d,Xq as e,Yq as f,Zq as g,_q as h,ar as j,br as k,cr as l,dr as m,er as n,fr as o,gr as p,hr as q,ir as r}from"./chunk-r0jcmpv6.js";import"./chunk-xv34zbp4.js";export{n as useSlots,p as useAttrs,h as setGlobalProvide,c as setCurrentInstance,e as resetComponentState,f as provide,l as onErrorCaptured,k as nextTick,g as inject,m as handleError,d as getCurrentInstance,a as generateScopeId,r as generateCompositionRuntime,o as defineSlots,j as defineExpose,i as defineEmits,q as createProvideContext,b as createComponentInstance};
+let currentInstance = null;
+const instanceStack = [];
+let scopeCounter = 0;
+export function generateScopeId() {
+  return `stx-${++scopeCounter}`;
+}
+export function createComponentInstance(parent = null) {
+  return {
+    scopeId: generateScopeId(),
+    parent,
+    provides: new Map(parent?.provides),
+    exposed: null,
+    refs: {},
+    props: {},
+    attrs: {},
+    slots: {},
+    emit: () => {},
+    el: null,
+    errorCapturedHooks: [],
+    isMounted: !1
+  };
+}
+export function setCurrentInstance(instance) {
+  if (instance)
+    instanceStack.push(instance);
+  else if (instanceStack.length > 0)
+    instanceStack.pop();
+  currentInstance = instance || instanceStack[instanceStack.length - 1] || null;
+}
+export function getCurrentInstance() {
+  return currentInstance;
+}
+export function resetComponentState() {
+  currentInstance = null;
+  instanceStack.length = 0;
+}
+export function provide(key, value) {
+  if (currentInstance)
+    currentInstance.provides.set(key, value);
+  else
+    globalProvides.set(key, value);
+}
+export function inject(key, defaultValue) {
+  let instance = currentInstance;
+  while (instance) {
+    if (instance.provides.has(key))
+      return instance.provides.get(key);
+    instance = instance.parent;
+  }
+  if (globalProvides.has(key))
+    return globalProvides.get(key);
+  return defaultValue;
+}
+const globalProvides = new Map;
+export function setGlobalProvide(key, value) {
+  globalProvides.set(key, value);
+}
+export function defineEmits(_events) {
+  const instance = currentInstance, emit = (event, ...args) => {
+    if (typeof document > "u")
+      return;
+    if (instance?.el)
+      instance.el.dispatchEvent(new CustomEvent(event, {
+        detail: args.length === 1 ? args[0] : args,
+        bubbles: !0,
+        cancelable: !0
+      }));
+  };
+  if (instance)
+    instance.emit = emit;
+  return emit;
+}
+export function defineExpose(exposed) {
+  if (currentInstance)
+    currentInstance.exposed = exposed;
+}
+export function nextTick(fn) {
+  const p = Promise.resolve();
+  return fn ? p.then(fn) : p;
+}
+export function onErrorCaptured(hook) {
+  if (currentInstance)
+    currentInstance.errorCapturedHooks.push(hook);
+}
+export function handleError(error, instance, info) {
+  let current = instance?.parent;
+  while (current) {
+    for (const hook of current.errorCapturedHooks)
+      if (hook(error, instance, info) === !1)
+        return;
+    current = current.parent;
+  }
+}
+export function useSlots() {
+  return currentInstance?.slots ?? {};
+}
+export function defineSlots() {
+  return currentInstance?.slots ?? {};
+}
+export function useAttrs() {
+  return currentInstance?.attrs ?? {};
+}
+export function createProvideContext(parentContext) {
+  const provides = parentContext.__provides ? new Map(Object.entries(parentContext.__provides)) : new Map;
+  return {
+    ...parentContext,
+    __provides: provides,
+    __provide(key, value) {
+      provides.set(key, value);
+    },
+    __inject(key, defaultValue) {
+      if (provides.has(key))
+        return provides.get(key);
+      if (parentContext.__provides) {
+        const parentProvides = parentContext.__provides instanceof Map ? parentContext.__provides : new Map(Object.entries(parentContext.__provides));
+        if (parentProvides.has(key))
+          return parentProvides.get(key);
+      }
+      return defaultValue;
+    }
+  };
+}
+export function generateCompositionRuntime() {
+  return `
+// STX Composition API Runtime
+(function() {
+  const _provides = new Map();
+  const _scopes = window.__stx_scopes || (window.__stx_scopes = {});
+  const _exposed = window.__stx_exposed || (window.__stx_exposed = {});
+
+  // provide() stores values in the nearest scope's provide map
+  window.__stx_provide = function(key, value) {
+    _provides.set(key, value);
+  };
+
+  // inject() walks up DOM ancestors with data-stx-scope to find provided values
+  window.__stx_inject = function(key, defaultValue, el) {
+    // Walk up the DOM tree
+    let current = el ? el.closest('[data-stx-scope]') : null;
+    while (current) {
+      const scopeId = current.getAttribute('data-stx-scope');
+      const scope = _scopes[scopeId];
+      if (scope && scope.__provided && scope.__provided.has(key)) {
+        return scope.__provided.get(key);
+      }
+      current = current.parentElement ? current.parentElement.closest('[data-stx-scope]') : null;
+    }
+    // Check global provides
+    if (_provides.has(key)) return _provides.get(key);
+    return defaultValue;
+  };
+
+  // defineEmits() returns an emit function
+  window.__stx_defineEmits = function(scopeId) {
+    return function emit(event, ...args) {
+      const el = document.querySelector('[data-stx-scope="' + scopeId + '"]');
+      if (el) {
+        el.dispatchEvent(new CustomEvent(event, {
+          detail: args.length === 1 ? args[0] : args,
+          bubbles: true,
+          cancelable: true
+        }));
+      }
+    };
+  };
+
+  // defineExpose() registers exposed properties
+  window.__stx_defineExpose = function(scopeId, exposed) {
+    _exposed[scopeId] = exposed;
+  };
+
+  // nextTick()
+  window.__stx_nextTick = function(fn) {
+    return Promise.resolve().then(fn);
+  };
+
+  // Template ref resolution
+  window.__stx_resolveRefs = function(scopeId) {
+    const scope = document.querySelector('[data-stx-scope="' + scopeId + '"]');
+    if (!scope) return {};
+    const refs = {};
+    // eslint-disable-next-line pickier/no-unused-vars
+    scope.querySelectorAll('[data-stx-ref]').forEach(function(el) {
+      refs[el.getAttribute('data-stx-ref')] = el;
+    });
+    return refs;
+  };
+})();
+`;
+}

package/dist/computed.js

@@ -1,14 +1,382 @@
-// @bun
-import"./chunk-xv34zbp4.js";var Y=null,S=[],F=new WeakMap;function I(z){let K=z,B=new Set,G={get value(){if(Y){let H=F.get(G);if(!H)H=new Set,F.set(G,H);H.add(Y)}return K},set value(H){if(!Object.is(K,H)){K=H,B.forEach((J)=>J(H));let L=F.get(G);if(L)L.forEach((J)=>J())}},subscribe(H){return B.add(H),()=>B.delete(H)},peek(){return K}};return G}function W(z){return z!==null&&typeof z==="object"&&"value"in z&&"subscribe"in z&&"peek"in z}function P(z){return W(z)?z.value:z}function j(z){let K={};for(let B in z)if(Object.prototype.hasOwnProperty.call(z,B))K[B]=I(z[B]);return K}function D(z){return I(z)}function U(z){let K=typeof z==="function",B=K?z:z.get,G=K?void 0:z.set,H=K?Object.is:z.equals||Object.is,L,J=!0,Q=new Set,X=new Set,_=()=>{if(J=!0,X.size>0){let N=T.value;X.forEach(($)=>$(N))}};function Z(){Q.clear();let N=Y;Y=_,S.push(_);try{return B()}finally{S.pop(),Y=N}}let T={get value(){if(Y){let N=F.get(T);if(!N)N=new Set,F.set(T,N);N.add(Y)}if(J){let N=Z();if(!H(L,N))L=N;J=!1}return L},set value(N){if(G)G(N);else console.warn("Computed property is readonly")},subscribe(N){return X.add(N),()=>X.delete(N)},peek(){if(J)L=B(),J=!1;return L},invalidate(){J=!0},get dirty(){return J},get deps(){return Q}};return T}function x(z,K,B={}){let{immediate:G=!1,deep:H=!1,flush:L="pre",once:J=!1}=B,Q,X=!0,_=!1,Z=()=>{if(W(z))return H?q(z.value):z.value;return z()},T=()=>{if(!X||_)return;let M=Z();if(Q!==void 0&&Object.is(Q,M)&&!H)return;let A=()=>{if(K(M,Q),Q=H?q(M):M,J)$()};if(L==="sync")A();else if(L==="post")queueMicrotask(A);else Promise.resolve().then(A)},N=null;if(W(z))N=z.subscribe(()=>T());else N=U(z).subscribe(()=>T());if(G)Q=void 0,T();else Q=Z();let $=()=>{if(X=!1,N)N(),N=null};return $.pause=()=>{_=!0},$.resume=()=>{_=!1},$}function E(z,K,B={}){let{immediate:G=!1,once:H=!1}=B,L=z.map((T)=>W(T)?T.value:void 0),J=!0,Q=!1,X=()=>{if(!J||Q)return;let T=z.map((N)=>W(N)?N.value:void 0);if(K(T,L),L=[...T],H)Z()},_=z.map((T)=>{if(W(T))return T.subscribe(()=>X());return()=>{}});if(G)X();let Z=()=>{J=!1,_.forEach((T)=>T())};return Z.pause=()=>{Q=!0},Z.resume=()=>{Q=!1},Z}function y(z,K={}){let{flush:B="pre"}=K,G,H=!0,L=!1,J=()=>{if(!H||L)return;if(G)G();let X=Y;Y=J,S.push(J);try{G=z()}finally{S.pop(),Y=X}};if(B==="sync")J();else if(B==="post")queueMicrotask(J);else Promise.resolve().then(J);let Q=()=>{if(H=!1,G)G()};return Q.pause=()=>{L=!0},Q.resume=()=>{L=!1},Q}function C(z,K={},B){let G=/@computed\s*\(\s*(\w+)\s*,\s*(.+?)\s*\)/gi;return z.replace(G,(H,L,J)=>{try{let X=Function(...Object.keys(K),`return ${J}`)(...Object.values(K));return K[L]=X,`<!-- computed: ${L} = ${X} -->`}catch(Q){return`<!-- computed error: ${L} - ${Q} -->`}})}function R(z,K={},B){let G=/@watch\s*\(\s*(\w+)\s*\)\s*([\s\S]*?)@endwatch/gi;return z.replace(G,(H,L,J)=>{return`
-      <script data-watch="${`watch-${Math.random().toString(36).substring(2,9)}`}">
+let activeEffect = null;
+const effectStack = [], refDeps = new WeakMap;
+export function ref(initialValue) {
+  let value = initialValue;
+  const subscribers = new Set, refObj = {
+    get value() {
+      if (activeEffect) {
+        let deps = refDeps.get(refObj);
+        if (!deps) {
+          deps = new Set;
+          refDeps.set(refObj, deps);
+        }
+        deps.add(activeEffect);
+      }
+      return value;
+    },
+    set value(newValue) {
+      if (!Object.is(value, newValue)) {
+        value = newValue;
+        subscribers.forEach((callback) => callback(newValue));
+        const deps = refDeps.get(refObj);
+        if (deps)
+          deps.forEach((effect) => effect());
+      }
+    },
+    subscribe(callback) {
+      subscribers.add(callback);
+      return () => subscribers.delete(callback);
+    },
+    peek() {
+      return value;
+    }
+  };
+  return refObj;
+}
+export function isRef(value) {
+  return value !== null && typeof value === "object" && "value" in value && "subscribe" in value && "peek" in value;
+}
+export function unref(value) {
+  return isRef(value) ? value.value : value;
+}
+export function toRefs(obj) {
+  const result = {};
+  for (const key in obj)
+    if (Object.prototype.hasOwnProperty.call(obj, key))
+      result[key] = ref(obj[key]);
+  return result;
+}
+export function shallowRef(initialValue) {
+  return ref(initialValue);
+}
+export function computed(getterOrOptions) {
+  const isFunction = typeof getterOrOptions === "function", getter = isFunction ? getterOrOptions : getterOrOptions.get, setter = isFunction ? void 0 : getterOrOptions.set, equals = isFunction ? Object.is : getterOrOptions.equals || Object.is;
+  let cachedValue, dirty = !0;
+  const deps = new Set, subscribers = new Set, effect = () => {
+    dirty = !0;
+    if (subscribers.size > 0) {
+      const newValue = computedRef.value;
+      subscribers.forEach((callback) => callback(newValue));
+    }
+  };
+  function calculate() {
+    deps.clear();
+    const previousEffect = activeEffect;
+    activeEffect = effect;
+    effectStack.push(effect);
+    try {
+      return getter();
+    } finally {
+      effectStack.pop();
+      activeEffect = previousEffect;
+    }
+  }
+  const computedRef = {
+    get value() {
+      if (activeEffect) {
+        let computedDeps = refDeps.get(computedRef);
+        if (!computedDeps) {
+          computedDeps = new Set;
+          refDeps.set(computedRef, computedDeps);
+        }
+        computedDeps.add(activeEffect);
+      }
+      if (dirty) {
+        const newValue = calculate();
+        if (!equals(cachedValue, newValue))
+          cachedValue = newValue;
+        dirty = !1;
+      }
+      return cachedValue;
+    },
+    set value(newValue) {
+      if (setter)
+        setter(newValue);
+      else
+        console.warn("Computed property is readonly");
+    },
+    subscribe(callback) {
+      subscribers.add(callback);
+      return () => subscribers.delete(callback);
+    },
+    peek() {
+      if (dirty) {
+        cachedValue = getter();
+        dirty = !1;
+      }
+      return cachedValue;
+    },
+    invalidate() {
+      dirty = !0;
+    },
+    get dirty() {
+      return dirty;
+    },
+    get deps() {
+      return deps;
+    }
+  };
+  return computedRef;
+}
+export function watch(source, callback, options = {}) {
+  const { immediate = !1, deep = !1, flush = "pre", once = !1 } = options;
+  let oldValue, isActive = !0, isPaused = !1;
+  const getValue = () => {
+    if (isRef(source))
+      return deep ? deepClone(source.value) : source.value;
+    return source();
+  }, run = () => {
+    if (!isActive || isPaused)
+      return;
+    const newValue = getValue();
+    if (oldValue !== void 0 && Object.is(oldValue, newValue) && !deep)
+      return;
+    const executeCallback = () => {
+      callback(newValue, oldValue);
+      oldValue = deep ? deepClone(newValue) : newValue;
+      if (once)
+        stop();
+    };
+    if (flush === "sync")
+      executeCallback();
+    else if (flush === "post")
+      queueMicrotask(executeCallback);
+    else
+      Promise.resolve().then(executeCallback);
+  };
+  let unsubscribe = null;
+  if (isRef(source))
+    unsubscribe = source.subscribe(() => run());
+  else
+    unsubscribe = computed(source).subscribe(() => run());
+  if (immediate) {
+    oldValue = void 0;
+    run();
+  } else
+    oldValue = getValue();
+  const stop = () => {
+    isActive = !1;
+    if (unsubscribe) {
+      unsubscribe();
+      unsubscribe = null;
+    }
+  };
+  stop.pause = () => {
+    isPaused = !0;
+  };
+  stop.resume = () => {
+    isPaused = !1;
+  };
+  return stop;
+}
+export function watchMultiple(sources, callback, options = {}) {
+  const { immediate = !1, once = !1 } = options;
+  let oldValues = sources.map((s) => isRef(s) ? s.value : void 0), isActive = !0, isPaused = !1;
+  const run = () => {
+    if (!isActive || isPaused)
+      return;
+    const newValues = sources.map((s) => isRef(s) ? s.value : void 0);
+    callback(newValues, oldValues);
+    oldValues = [...newValues];
+    if (once)
+      stop();
+  }, unsubscribes = sources.map((source) => {
+    if (isRef(source))
+      return source.subscribe(() => run());
+    return () => {};
+  });
+  if (immediate)
+    run();
+  const stop = () => {
+    isActive = !1;
+    unsubscribes.forEach((unsub) => unsub());
+  };
+  stop.pause = () => {
+    isPaused = !0;
+  };
+  stop.resume = () => {
+    isPaused = !1;
+  };
+  return stop;
+}
+export function watchEffect(effect, options = {}) {
+  const { flush = "pre" } = options;
+  let cleanup, isActive = !0, isPaused = !1;
+  const run = () => {
+    if (!isActive || isPaused)
+      return;
+    if (cleanup)
+      cleanup();
+    const previousEffect = activeEffect;
+    activeEffect = run;
+    effectStack.push(run);
+    try {
+      cleanup = effect();
+    } finally {
+      effectStack.pop();
+      activeEffect = previousEffect;
+    }
+  };
+  if (flush === "sync")
+    run();
+  else if (flush === "post")
+    queueMicrotask(run);
+  else
+    Promise.resolve().then(run);
+  const stop = () => {
+    isActive = !1;
+    if (cleanup)
+      cleanup();
+  };
+  stop.pause = () => {
+    isPaused = !0;
+  };
+  stop.resume = () => {
+    isPaused = !1;
+  };
+  return stop;
+}
+export function processComputedDirectives(template, context = {}, _filePath) {
+  const computedRegex = /@computed\s*\(\s*(\w+)\s*,\s*(.+?)\s*\)/gi;
+  return template.replace(computedRegex, (_, name, expression) => {
+    try {
+      const value = Function(...Object.keys(context), `return ${expression}`)(...Object.values(context));
+      context[name] = value;
+      return `<!-- computed: ${name} = ${value} -->`;
+    } catch (error) {
+      return `<!-- computed error: ${name} - ${error} -->`;
+    }
+  });
+}
+export function processWatchDirectives(template, _context = {}, _filePath) {
+  const watchRegex = /@watch\s*\(\s*(\w+)\s*\)\s*([\s\S]*?)@endwatch/gi;
+  return template.replace(watchRegex, (_, source, handler) => {
+    return `
+      <script data-watch="${`watch-${Math.random().toString(36).substring(2, 9)}`}">
         (function() {
-          // Watch implementation for ${L}
-          const handler = ${J.trim()};
-          if (window.__stxState && window.__stxState['${L}']) {
-            window.__stxState['${L}'].subscribe(function(newValue) {
+          // Watch implementation for ${source}
+          const handler = ${handler.trim()};
+          if (window.__stxState && window.__stxState['${source}']) {
+            window.__stxState['${source}'].subscribe(function(newValue) {
               handler(newValue);
             });
           }
         })();
       </script>
-    `})}function q(z){if(z===null||typeof z!=="object")return z;if(Array.isArray(z))return z.map((B)=>q(B));if(z instanceof Date)return new Date(z.getTime());if(z instanceof Map){let B=new Map;return z.forEach((G,H)=>B.set(q(H),q(G))),B}if(z instanceof Set){let B=new Set;return z.forEach((G)=>B.add(q(G))),B}let K={};for(let B in z)if(Object.prototype.hasOwnProperty.call(z,B))K[B]=q(z[B]);return K}function O(z,K=100){let B=I(z()),G=null,H=()=>{if(G)clearTimeout(G);G=setTimeout(()=>{B.value=z()},K)};return U(z).subscribe(()=>H()),{get value(){return B.value},set value(J){console.warn("Debounced computed is readonly")},subscribe:B.subscribe,peek:B.peek,invalidate(){H()},get dirty(){return!1},get deps(){return new Set}}}function h(z,K=100){let B=I(z()),G=0,H=()=>{let J=Date.now();if(J-G>=K)G=J,B.value=z()};return U(z).subscribe(()=>H()),{get value(){return B.value},set value(J){console.warn("Throttled computed is readonly")},subscribe:B.subscribe,peek:B.peek,invalidate(){H()},get dirty(){return!1},get deps(){return new Set}}}var g={ref:I,computed:U,watch:x,watchMultiple:E,watchEffect:y,isRef:W,unref:P,toRefs:j,shallowRef:D,debouncedComputed:O,throttledComputed:h,processComputedDirectives:C,processWatchDirectives:R};export{E as watchMultiple,y as watchEffect,x as watch,P as unref,j as toRefs,h as throttledComputed,E as stxWatchMultiple,y as stxWatchEffect,x as stxWatch,P as stxUnref,j as stxToRefs,h as stxThrottledComputed,D as stxShallowRef,I as stxRef,W as stxIsRef,O as stxDebouncedComputed,U as stxComputed,D as shallowRef,I as ref,R as processWatchDirectives,C as processComputedDirectives,W as isRef,g as default,O as debouncedComputed,U as computed};
+    `;
+  });
+}
+function deepClone(value) {
+  if (value === null || typeof value !== "object")
+    return value;
+  if (Array.isArray(value))
+    return value.map((item) => deepClone(item));
+  if (value instanceof Date)
+    return new Date(value.getTime());
+  if (value instanceof Map) {
+    const map = new Map;
+    value.forEach((v, k) => map.set(deepClone(k), deepClone(v)));
+    return map;
+  }
+  if (value instanceof Set) {
+    const set = new Set;
+    value.forEach((v) => set.add(deepClone(v)));
+    return set;
+  }
+  const cloned = {};
+  for (const key in value)
+    if (Object.prototype.hasOwnProperty.call(value, key))
+      cloned[key] = deepClone(value[key]);
+  return cloned;
+}
+export function debouncedComputed(getter, delay = 100) {
+  const result = ref(getter());
+  let timeoutId = null;
+  const debouncedUpdate = () => {
+    if (timeoutId)
+      clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => {
+      result.value = getter();
+    }, delay);
+  };
+  computed(getter).subscribe(() => debouncedUpdate());
+  return {
+    get value() {
+      return result.value;
+    },
+    set value(_) {
+      console.warn("Debounced computed is readonly");
+    },
+    subscribe: result.subscribe,
+    peek: result.peek,
+    invalidate() {
+      debouncedUpdate();
+    },
+    get dirty() {
+      return !1;
+    },
+    get deps() {
+      return new Set;
+    }
+  };
+}
+export function throttledComputed(getter, limit = 100) {
+  const result = ref(getter());
+  let lastRun = 0;
+  const throttledUpdate = () => {
+    const now = Date.now();
+    if (now - lastRun >= limit) {
+      lastRun = now;
+      result.value = getter();
+    }
+  };
+  computed(getter).subscribe(() => throttledUpdate());
+  return {
+    get value() {
+      return result.value;
+    },
+    set value(_) {
+      console.warn("Throttled computed is readonly");
+    },
+    subscribe: result.subscribe,
+    peek: result.peek,
+    invalidate() {
+      throttledUpdate();
+    },
+    get dirty() {
+      return !1;
+    },
+    get deps() {
+      return new Set;
+    }
+  };
+}
+
+export {
+  ref as stxRef,
+  computed as stxComputed,
+  watch as stxWatch,
+  watchMultiple as stxWatchMultiple,
+  watchEffect as stxWatchEffect,
+  isRef as stxIsRef,
+  unref as stxUnref,
+  toRefs as stxToRefs,
+  shallowRef as stxShallowRef,
+  debouncedComputed as stxDebouncedComputed,
+  throttledComputed as stxThrottledComputed
+};
+export default {
+  ref,
+  computed,
+  watch,
+  watchMultiple,
+  watchEffect,
+  isRef,
+  unref,
+  toRefs,
+  shallowRef,
+  debouncedComputed,
+  throttledComputed,
+  processComputedDirectives,
+  processWatchDirectives
+};