@fluixi/core 1.0.0-alpha.83 → 1.0.0-alpha.84

package/dist/src/lib/context/context.d.ts

@@ -28,7 +28,7 @@ export interface ProviderProps<Child> {
     children?: Child extends Record<any, any> ? PickChildren<Child> : never;
 }
 /**
- * Lazy-safe form — pass the component's `props` so `children` is read through a
+ * Lazy-safe form: pass the component's `props` so `children` is read through a
  * getter (inside the stamped scope), never materialised early. This is the
  * recommended way to wrap an <Outlet/>.
  *
@@ -40,10 +40,25 @@ export declare function createProvider<T>(context: Context<T>, value: T | Access
     children?: any;
 }): ComponentChild;
 /**
- * @deprecated Eager form — `{ context, value, children }` reads `children` before
+ * @deprecated Eager form: `{ context, value, children }` reads `children` before
  * the context is stamped (see warnEagerProvider). Use `createProvider(context,
  * value, props)` or `<Context.Provider>` instead.
  */
+/**
+ * Provide a context value to a subtree, without writing the `Provider` tag.
+ *
+ * Takes either a `Context` from `createContext` or a provider component, so it works for
+ * both shapes the context API hands back. `value` may be an accessor, in which case
+ * descendants see it change.
+ *
+ * Reach for the `Provider` tag in markup; this is for providing a value from code, such as
+ * a wrapper that supplies context around children it was handed.
+ *
+ * @example
+ * ```ts
+ * createProvider(ThemeContext, 'dark', { children: () => renderPage() });
+ * ```
+ */
 export declare function createProvider<T, S = Children>(props: ContextProvider<T, S>): ComponentChild;
 /**
  * Creates a context with a provider component
@@ -51,10 +66,6 @@ export declare function createProvider<T, S = Children>(props: ContextProvider<T
  * Returns both the context and a convenience component that combines
  * context creation with the provider.
  *
- * @template T - Type of the context value
- * @param {T} defaultValue - Default value for the context
- * @returns {[Context<T>, (props: { value: T | Accessor<T>; children: TemplateResult | TemplateResult[] }) => TemplateResult]} Context and provider component
- *
  * @example
  * ```typescript
  * import { createContextWithProvider } from '@fluixi/core/context';
@@ -92,10 +103,6 @@ export declare function createContextWithProvider<T, U>(defaultValue: T): [Conte
  *
  * Utility function to avoid deeply nested Provider components.
  *
- * @param {Array<[Context<any>, any]>} contexts - Array of [context, value] tuples
- * @param {TemplateResult | TemplateResult[]} children - Children to render
- * @returns {TemplateResult} Nested providers with children
- *
  * @example
  * ```typescript
  * import { composeProviders, createContext } from '@fluixi/core/context';
@@ -130,10 +137,6 @@ export declare function composeProviders(contexts: Array<[Context<any>, any]>, c
  *
  * Alternative to useContext hook, useful for rendering props patterns.
  *
- * @template T - Type of the context value
- * @param {Context<T>} context - Context to consume
- * @returns {(props: { children: (value: T) => TemplateResult }) => TemplateResult} Consumer component
- *
  * @example
  * ```typescript
  * import { createContext, createConsumer } from '@fluixi/core/context';
@@ -165,11 +168,6 @@ export declare function createConsumer<T>(context: Context<T>): (props: {
  *
  * Useful for creating context-based stores or services.
  *
- * @template T - Type of the context value
- * @param {Context<T>} context - Context to use
- * @param {() => T} factory - Factory function to create the context value
- * @returns {T} Context value
- *
  * @example
  * ```typescript
  * import { createContext, useProvide, Provider } from '@fluixi/core/context';
@@ -211,10 +209,6 @@ export declare function useProvide<T>(context: Context<T>, factory: () => T): T;
 /**
  * Creates a scoped context that only exists within a specific component tree
  *
- * @template T - Type of the context value
- * @param {T} defaultValue - Default value for the context
- * @returns {Context<T>} Scoped context object
- *
  * @example
  * ```typescript
  * import { createContext } from '@fluixi/core/context';
@@ -226,13 +220,9 @@ export declare function useProvide<T>(context: Context<T>, factory: () => T): T;
 /**
  * Create a context for sharing state across component tree
  *
- * Section 9: Context is lookup-based, works on server and client
+ * Context is lookup-based, works on server and client
  * Supports nested contexts and complex values
  *
- * @template T - Context value type
- * @param {T} defaultValue - Default value
- * @returns {Context<T>} Context object with Provider
- *
  * @example
  * ```typescript
  * // Simple context
@@ -260,10 +250,6 @@ export declare function useProvide<T>(context: Context<T>, factory: () => T): T;
 /**
  * Creates a scoped context that only exists within a specific component tree
  *
- * @template T - Type of the context value
- * @param {T} defaultValue - Default value for the context
- * @returns {Context<T>} Scoped context object
- *
  * @example
  * ```typescript
  * import { createContext } from '@fluixi/core';
@@ -307,11 +293,7 @@ export declare function createContext<T>(defaultValue?: T, name?: string): {
 /**
  * Use context value from nearest Provider
  *
- * Section 9: Lookup-based, no subscriptions on server
- *
- * @template T - Context value type
- * @param {Context} context - Context to use
- * @returns {T} Context value
+ * Lookup-based, no subscriptions on server
  *
  * @example
  * ```typescript

package/dist/src/lib/context/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../../src/lib/context/context.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../../src/lib/context/context.ts"],"names":[],"mappings":"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"}

package/dist/src/lib/context/context.js

@@ -10,10 +10,6 @@ import { readChildren, } from '@fluixi/reactive/signal';
  *
  * This wraps @fluixi/reactive's Provider for use with Lit templates.
  *
- * @template T - Type of the context value
- * @param {ContextProvider<T>} props - Component props
- * @returns {TemplateResult} Rendered children with context
- *
  * @example
  * ```typescript
  * import { createContext, Provider } from '@fluixi/core/context';
@@ -80,9 +76,9 @@ function warnEagerProvider() {
         'routed <Outlet/> that has siblings inside the provider renders detached and its ' +
         'descendants see no context under SSR. Use the lazy form instead:\n' +
         '  createProvider(Context, value, props)   // children stays a getter\n' +
-        '  // or JSX:  <Context.Provider value={…}>{props.children}</Context.Provider>');
+        '  // or JSX:  <Context.Provider value={...}>{props.children}</Context.Provider>');
 }
-// Returns the Provider's rendered output, not a component — it was annotated
+// Returns the Provider's rendered output, not a component, it was annotated
 // `Component<T>`, which made `<MyProvider>` fail as a JSX element.
 export function createProvider(a, value, childProps) {
     // Distinguish the two overloads: a Context (from createContext) exposes `.Provider`,
@@ -98,7 +94,7 @@ export function createProvider(a, value, childProps) {
     // Always read children through a getter so they render INSIDE the stamped scope.
     // For the lazy form `childProps.children` is still a getter here (untouched); for
     // the eager form the caller already materialised it, so this can only mitigate,
-    // not fully fix — hence the deprecation warning above.
+    // not fully fix: hence the deprecation warning above.
     const sourceProps = isLazyForm ? childProps : a;
     return context.Provider({
         value: resolvedValue,
@@ -118,10 +114,6 @@ export function createProvider(a, value, childProps) {
  * Returns both the context and a convenience component that combines
  * context creation with the provider.
  *
- * @template T - Type of the context value
- * @param {T} defaultValue - Default value for the context
- * @returns {[Context<T>, (props: { value: T | Accessor<T>; children: TemplateResult | TemplateResult[] }) => TemplateResult]} Context and provider component
- *
  * @example
  * ```typescript
  * import { createContextWithProvider } from '@fluixi/core/context';
@@ -167,10 +159,6 @@ export function createContextWithProvider(defaultValue) {
  *
  * Utility function to avoid deeply nested Provider components.
  *
- * @param {Array<[Context<any>, any]>} contexts - Array of [context, value] tuples
- * @param {TemplateResult | TemplateResult[]} children - Children to render
- * @returns {TemplateResult} Nested providers with children
- *
  * @example
  * ```typescript
  * import { composeProviders, createContext } from '@fluixi/core/context';
@@ -216,10 +204,6 @@ export function composeProviders(contexts, children) {
  *
  * Alternative to useContext hook, useful for rendering props patterns.
  *
- * @template T - Type of the context value
- * @param {Context<T>} context - Context to consume
- * @returns {(props: { children: (value: T) => TemplateResult }) => TemplateResult} Consumer component
- *
  * @example
  * ```typescript
  * import { createContext, createConsumer } from '@fluixi/core/context';
@@ -254,11 +238,6 @@ export function createConsumer(context) {
  *
  * Useful for creating context-based stores or services.
  *
- * @template T - Type of the context value
- * @param {Context<T>} context - Context to use
- * @param {() => T} factory - Factory function to create the context value
- * @returns {T} Context value
- *
  * @example
  * ```typescript
  * import { createContext, useProvide, Provider } from '@fluixi/core/context';
@@ -308,10 +287,6 @@ export function useProvide(context, factory) {
 /**
  * Creates a scoped context that only exists within a specific component tree
  *
- * @template T - Type of the context value
- * @param {T} defaultValue - Default value for the context
- * @returns {Context<T>} Scoped context object
- *
  * @example
  * ```typescript
  * import { createContext } from '@fluixi/core/context';
@@ -332,13 +307,9 @@ export function useProvide(context, factory) {
 /**
  * Create a context for sharing state across component tree
  *
- * Section 9: Context is lookup-based, works on server and client
+ * Context is lookup-based, works on server and client
  * Supports nested contexts and complex values
  *
- * @template T - Context value type
- * @param {T} defaultValue - Default value
- * @returns {Context<T>} Context object with Provider
- *
  * @example
  * ```typescript
  * // Simple context
@@ -366,10 +337,6 @@ export function useProvide(context, factory) {
 /**
  * Creates a scoped context that only exists within a specific component tree
  *
- * @template T - Type of the context value
- * @param {T} defaultValue - Default value for the context
- * @returns {Context<T>} Scoped context object
- *
  * @example
  * ```typescript
  * import { createContext } from '@fluixi/core';
@@ -408,9 +375,9 @@ export function createContext(defaultValue, name) {
         if (props.debug === true) {
         }
         // Pass children LAZILY (a getter). The reactive Provider reads children inside
-        // its render effect, AFTER stamping the context on the owner. Reading
+        // its render effect, after stamping the context on the owner. Reading
         // props.children here (e.g. `children: props.children`) evaluates the imperative
-        // `get children()` getter eagerly, so the children — and any <Outlet/> in them —
+        // `get children()` getter eagerly, so the children, and any <Outlet/> in them,
         // render before the context is available.
         return context.Provider({
             value: props.value,
@@ -434,11 +401,7 @@ export function createContext(defaultValue, name) {
 /**
  * Use context value from nearest Provider
  *
- * Section 9: Lookup-based, no subscriptions on server
- *
- * @template T - Context value type
- * @param {Context} context - Context to use
- * @returns {T} Context value
+ * Lookup-based, no subscriptions on server
  *
  * @example
  * ```typescript
@@ -456,7 +419,7 @@ export function createContext(defaultValue, name) {
  * ```
  */
 export function useContext(context) {
-    // Use reactive context lookup — walks up Owner chain
+    // Use reactive context lookup: walks up Owner chain
     const value = useReactiveContext(context);
     return value !== undefined ? value : context.defaultValue;
 }

package/dist/src/lib/context/context.mjs

@@ -1 +1,99 @@
-import{asProvider as C}from"@fluixi/dom";import{createContext as v,useContext as p}from"@fluixi/reactive/signal";import{readChildren as x}from"@fluixi/reactive/signal";var d=!1;function T(){d||(d=!0,!(typeof process<"u")&&console.warn("[fluixi] createProvider({ context, value, children }) reads `children` eagerly: the object literal materialises `children` BEFORE the context is stamped, so a routed <Outlet/> that has siblings inside the provider renders detached and its descendants see no context under SSR. Use the lazy form instead:\n  createProvider(Context, value, props)   // children stays a getter\n  // or JSX:  <Context.Provider value={…}>{props.children}</Context.Provider>"))}function a(e,r,n){let t=!!e?.Provider,o=t?e:e.context,i=t?r:e.value,c=t?!1:e.debug??!1;t||T();let l=typeof i=="function"?i():i,u=t?n:e;return o.Provider({value:l,get children(){return u?.children},debug:c})}function S(e){let r=f(e);return[r,t=>a(r,t.value,t)]}function h(e,r){if(e.length===0)return x(()=>r);let[n,t]=e[0],o=e.slice(1);return a(n,t,{get children(){return h(o,r)}})}function A(e){return r=>{let n=s(e);return r.children(n)}}function R(e,r){let n=s(e);return n===e.defaultValue?r():n}function f(e,r){let n=v(e,r),t=o=>(o.debug,n.Provider({value:o.value,get children(){return o.children},debug:o.debug}));return typeof Symbol<"u"&&Symbol.for&&(t.$$typeof=Symbol.for("react.provider")),t.$$typeof=Symbol.for("react.provider"),{id:n.id,Provider:C(t),defaultValue:e}}function s(e){let r=p(e);return r!==void 0?r:e.defaultValue}export{h as composeProviders,A as createConsumer,f as createContext,S as createContextWithProvider,a as createProvider,s as useContext,R as useProvide};
+// src/lib/context/context.ts
+import { asProvider } from "@fluixi/dom";
+import { createContext as createReactiveContext, useContext as useReactiveContext } from "@fluixi/reactive/signal";
+import {
+  readChildren
+} from "@fluixi/reactive/signal";
+var _warnedEagerProvider = false;
+function warnEagerProvider() {
+  if (_warnedEagerProvider) return;
+  _warnedEagerProvider = true;
+  if (typeof process !== "undefined" && true) return;
+  console.warn(
+    "[fluixi] createProvider({ context, value, children }) reads `children` eagerly: the object literal materialises `children` BEFORE the context is stamped, so a routed <Outlet/> that has siblings inside the provider renders detached and its descendants see no context under SSR. Use the lazy form instead:\n  createProvider(Context, value, props)   // children stays a getter\n  // or JSX:  <Context.Provider value={...}>{props.children}</Context.Provider>"
+  );
+}
+function createProvider(a, value, childProps) {
+  const isLazyForm = !!a?.Provider;
+  const context = isLazyForm ? a : a.context;
+  const rawValue = isLazyForm ? value : a.value;
+  const debug = isLazyForm ? false : a.debug ?? false;
+  if (!isLazyForm) warnEagerProvider();
+  const resolvedValue = typeof rawValue === "function" ? rawValue() : rawValue;
+  const sourceProps = isLazyForm ? childProps : a;
+  return context.Provider({
+    value: resolvedValue,
+    get children() {
+      return sourceProps?.children;
+    },
+    debug
+  });
+}
+function createContextWithProvider(defaultValue) {
+  const context = createContext(defaultValue);
+  const provider = (props) => {
+    return createProvider(context, props.value, props);
+  };
+  return [context, provider];
+}
+function composeProviders(contexts, children) {
+  if (contexts.length === 0) {
+    return readChildren(() => children);
+  }
+  const [context, value] = contexts[0];
+  const remaining = contexts.slice(1);
+  return createProvider(context, value, {
+    get children() {
+      return composeProviders(remaining, children);
+    }
+  });
+}
+function createConsumer(context) {
+  return (props) => {
+    const value = useContext(context);
+    return props.children(value);
+  };
+}
+function useProvide(context, factory) {
+  const existing = useContext(context);
+  if (existing === context.defaultValue) {
+    return factory();
+  }
+  return existing;
+}
+function createContext(defaultValue, name) {
+  const context = createReactiveContext(defaultValue, name);
+  const Provider = (props) => {
+    if (props.debug === true) {
+    }
+    return context.Provider({
+      value: props.value,
+      get children() {
+        return props.children;
+      },
+      debug: props.debug
+    });
+  };
+  if (typeof Symbol !== "undefined" && Symbol.for) {
+    Provider.$$typeof = /* @__PURE__ */ Symbol.for("react.provider");
+  }
+  Provider.$$typeof = /* @__PURE__ */ Symbol.for("react.provider");
+  return {
+    id: context.id,
+    Provider: asProvider(Provider),
+    defaultValue
+  };
+}
+function useContext(context) {
+  const value = useReactiveContext(context);
+  return value !== void 0 ? value : context.defaultValue;
+}
+export {
+  composeProviders,
+  createConsumer,
+  createContext,
+  createContextWithProvider,
+  createProvider,
+  useContext,
+  useProvide
+};

package/dist/src/lib/context/index.cjs

@@ -1 +1,120 @@
-"use strict";var c=Object.defineProperty;var m=Object.getOwnPropertyDescriptor;var g=Object.getOwnPropertyNames;var b=Object.prototype.hasOwnProperty;var S=(e,r)=>{for(var t in r)c(e,t,{get:r[t],enumerable:!0})},A=(e,r,t,n)=>{if(r&&typeof r=="object"||typeof r=="function")for(let o of g(r))!b.call(e,o)&&o!==t&&c(e,o,{get:()=>r[o],enumerable:!(n=m(r,o))||n.enumerable});return e};var R=e=>A(c({},"__esModule",{value:!0}),e);var k={};S(k,{composeProviders:()=>l,createConsumer:()=>T,createContext:()=>u,createContextWithProvider:()=>x,createProvider:()=>d,useContext:()=>a,useProvide:()=>f});module.exports=R(k);var v=require("@fluixi/dom"),i=require("@fluixi/reactive/signal"),p=require("@fluixi/reactive/signal"),C=!1;function V(){C||(C=!0,!(typeof process<"u")&&console.warn("[fluixi] createProvider({ context, value, children }) reads `children` eagerly: the object literal materialises `children` BEFORE the context is stamped, so a routed <Outlet/> that has siblings inside the provider renders detached and its descendants see no context under SSR. Use the lazy form instead:\n  createProvider(Context, value, props)   // children stays a getter\n  // or JSX:  <Context.Provider value={…}>{props.children}</Context.Provider>"))}function d(e,r,t){let n=!!e?.Provider,o=n?e:e.context,s=n?r:e.value,h=n?!1:e.debug??!1;n||V();let y=typeof s=="function"?s():s,P=n?t:e;return o.Provider({value:y,get children(){return P?.children},debug:h})}function x(e){let r=u(e);return[r,n=>d(r,n.value,n)]}function l(e,r){if(e.length===0)return(0,p.readChildren)(()=>r);let[t,n]=e[0],o=e.slice(1);return d(t,n,{get children(){return l(o,r)}})}function T(e){return r=>{let t=a(e);return r.children(t)}}function f(e,r){let t=a(e);return t===e.defaultValue?r():t}function u(e,r){let t=(0,i.createContext)(e,r),n=o=>(o.debug,t.Provider({value:o.value,get children(){return o.children},debug:o.debug}));return typeof Symbol<"u"&&Symbol.for&&(n.$$typeof=Symbol.for("react.provider")),n.$$typeof=Symbol.for("react.provider"),{id:t.id,Provider:(0,v.asProvider)(n),defaultValue:e}}function a(e){let r=(0,i.useContext)(e);return r!==void 0?r:e.defaultValue}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/context/index.ts
+var index_exports = {};
+__export(index_exports, {
+  composeProviders: () => composeProviders,
+  createConsumer: () => createConsumer,
+  createContext: () => createContext,
+  createContextWithProvider: () => createContextWithProvider,
+  createProvider: () => createProvider,
+  useContext: () => useContext,
+  useProvide: () => useProvide
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/lib/context/context.ts
+var import_dom = require("@fluixi/dom");
+var import_signal = require("@fluixi/reactive/signal");
+var import_signal2 = require("@fluixi/reactive/signal");
+var _warnedEagerProvider = false;
+function warnEagerProvider() {
+  if (_warnedEagerProvider) return;
+  _warnedEagerProvider = true;
+  if (typeof process !== "undefined" && true) return;
+  console.warn(
+    "[fluixi] createProvider({ context, value, children }) reads `children` eagerly: the object literal materialises `children` BEFORE the context is stamped, so a routed <Outlet/> that has siblings inside the provider renders detached and its descendants see no context under SSR. Use the lazy form instead:\n  createProvider(Context, value, props)   // children stays a getter\n  // or JSX:  <Context.Provider value={...}>{props.children}</Context.Provider>"
+  );
+}
+function createProvider(a, value, childProps) {
+  const isLazyForm = !!a?.Provider;
+  const context = isLazyForm ? a : a.context;
+  const rawValue = isLazyForm ? value : a.value;
+  const debug = isLazyForm ? false : a.debug ?? false;
+  if (!isLazyForm) warnEagerProvider();
+  const resolvedValue = typeof rawValue === "function" ? rawValue() : rawValue;
+  const sourceProps = isLazyForm ? childProps : a;
+  return context.Provider({
+    value: resolvedValue,
+    get children() {
+      return sourceProps?.children;
+    },
+    debug
+  });
+}
+function createContextWithProvider(defaultValue) {
+  const context = createContext(defaultValue);
+  const provider = (props) => {
+    return createProvider(context, props.value, props);
+  };
+  return [context, provider];
+}
+function composeProviders(contexts, children) {
+  if (contexts.length === 0) {
+    return (0, import_signal2.readChildren)(() => children);
+  }
+  const [context, value] = contexts[0];
+  const remaining = contexts.slice(1);
+  return createProvider(context, value, {
+    get children() {
+      return composeProviders(remaining, children);
+    }
+  });
+}
+function createConsumer(context) {
+  return (props) => {
+    const value = useContext(context);
+    return props.children(value);
+  };
+}
+function useProvide(context, factory) {
+  const existing = useContext(context);
+  if (existing === context.defaultValue) {
+    return factory();
+  }
+  return existing;
+}
+function createContext(defaultValue, name) {
+  const context = (0, import_signal.createContext)(defaultValue, name);
+  const Provider = (props) => {
+    if (props.debug === true) {
+    }
+    return context.Provider({
+      value: props.value,
+      get children() {
+        return props.children;
+      },
+      debug: props.debug
+    });
+  };
+  if (typeof Symbol !== "undefined" && Symbol.for) {
+    Provider.$$typeof = /* @__PURE__ */ Symbol.for("react.provider");
+  }
+  Provider.$$typeof = /* @__PURE__ */ Symbol.for("react.provider");
+  return {
+    id: context.id,
+    Provider: (0, import_dom.asProvider)(Provider),
+    defaultValue
+  };
+}
+function useContext(context) {
+  const value = (0, import_signal.useContext)(context);
+  return value !== void 0 ? value : context.defaultValue;
+}

package/dist/src/lib/context/index.mjs

@@ -1 +1,99 @@
-import{asProvider as p}from"@fluixi/dom";import{createContext as x,useContext as T}from"@fluixi/reactive/signal";import{readChildren as f}from"@fluixi/reactive/signal";var s=!1;function h(){s||(s=!0,!(typeof process<"u")&&console.warn("[fluixi] createProvider({ context, value, children }) reads `children` eagerly: the object literal materialises `children` BEFORE the context is stamped, so a routed <Outlet/> that has siblings inside the provider renders detached and its descendants see no context under SSR. Use the lazy form instead:\n  createProvider(Context, value, props)   // children stays a getter\n  // or JSX:  <Context.Provider value={…}>{props.children}</Context.Provider>"))}function d(e,r,n){let t=!!e?.Provider,o=t?e:e.context,i=t?r:e.value,u=t?!1:e.debug??!1;t||h();let C=typeof i=="function"?i():i,v=t?n:e;return o.Provider({value:C,get children(){return v?.children},debug:u})}function y(e){let r=l(e);return[r,t=>d(r,t.value,t)]}function c(e,r){if(e.length===0)return f(()=>r);let[n,t]=e[0],o=e.slice(1);return d(n,t,{get children(){return c(o,r)}})}function P(e){return r=>{let n=a(e);return r.children(n)}}function m(e,r){let n=a(e);return n===e.defaultValue?r():n}function l(e,r){let n=x(e,r),t=o=>(o.debug,n.Provider({value:o.value,get children(){return o.children},debug:o.debug}));return typeof Symbol<"u"&&Symbol.for&&(t.$$typeof=Symbol.for("react.provider")),t.$$typeof=Symbol.for("react.provider"),{id:n.id,Provider:p(t),defaultValue:e}}function a(e){let r=T(e);return r!==void 0?r:e.defaultValue}export{c as composeProviders,P as createConsumer,l as createContext,y as createContextWithProvider,d as createProvider,a as useContext,m as useProvide};
+// src/lib/context/context.ts
+import { asProvider } from "@fluixi/dom";
+import { createContext as createReactiveContext, useContext as useReactiveContext } from "@fluixi/reactive/signal";
+import {
+  readChildren
+} from "@fluixi/reactive/signal";
+var _warnedEagerProvider = false;
+function warnEagerProvider() {
+  if (_warnedEagerProvider) return;
+  _warnedEagerProvider = true;
+  if (typeof process !== "undefined" && true) return;
+  console.warn(
+    "[fluixi] createProvider({ context, value, children }) reads `children` eagerly: the object literal materialises `children` BEFORE the context is stamped, so a routed <Outlet/> that has siblings inside the provider renders detached and its descendants see no context under SSR. Use the lazy form instead:\n  createProvider(Context, value, props)   // children stays a getter\n  // or JSX:  <Context.Provider value={...}>{props.children}</Context.Provider>"
+  );
+}
+function createProvider(a, value, childProps) {
+  const isLazyForm = !!a?.Provider;
+  const context = isLazyForm ? a : a.context;
+  const rawValue = isLazyForm ? value : a.value;
+  const debug = isLazyForm ? false : a.debug ?? false;
+  if (!isLazyForm) warnEagerProvider();
+  const resolvedValue = typeof rawValue === "function" ? rawValue() : rawValue;
+  const sourceProps = isLazyForm ? childProps : a;
+  return context.Provider({
+    value: resolvedValue,
+    get children() {
+      return sourceProps?.children;
+    },
+    debug
+  });
+}
+function createContextWithProvider(defaultValue) {
+  const context = createContext(defaultValue);
+  const provider = (props) => {
+    return createProvider(context, props.value, props);
+  };
+  return [context, provider];
+}
+function composeProviders(contexts, children) {
+  if (contexts.length === 0) {
+    return readChildren(() => children);
+  }
+  const [context, value] = contexts[0];
+  const remaining = contexts.slice(1);
+  return createProvider(context, value, {
+    get children() {
+      return composeProviders(remaining, children);
+    }
+  });
+}
+function createConsumer(context) {
+  return (props) => {
+    const value = useContext(context);
+    return props.children(value);
+  };
+}
+function useProvide(context, factory) {
+  const existing = useContext(context);
+  if (existing === context.defaultValue) {
+    return factory();
+  }
+  return existing;
+}
+function createContext(defaultValue, name) {
+  const context = createReactiveContext(defaultValue, name);
+  const Provider = (props) => {
+    if (props.debug === true) {
+    }
+    return context.Provider({
+      value: props.value,
+      get children() {
+        return props.children;
+      },
+      debug: props.debug
+    });
+  };
+  if (typeof Symbol !== "undefined" && Symbol.for) {
+    Provider.$$typeof = /* @__PURE__ */ Symbol.for("react.provider");
+  }
+  Provider.$$typeof = /* @__PURE__ */ Symbol.for("react.provider");
+  return {
+    id: context.id,
+    Provider: asProvider(Provider),
+    defaultValue
+  };
+}
+function useContext(context) {
+  const value = useReactiveContext(context);
+  return value !== void 0 ? value : context.defaultValue;
+}
+export {
+  composeProviders,
+  createConsumer,
+  createContext,
+  createContextWithProvider,
+  createProvider,
+  useContext,
+  useProvide
+};

package/dist/src/lib/control-flow.cjs

@@ -1 +1,35 @@
-"use strict";var y=Object.defineProperty;var P=Object.getOwnPropertyDescriptor;var n=Object.getOwnPropertyNames;var a=Object.prototype.hasOwnProperty;var h=(p,r)=>{for(var t in r)y(p,t,{get:r[t],enumerable:!0})},S=(p,r,t,s)=>{if(r&&typeof r=="object"||typeof r=="function")for(let e of n(r))!a.call(p,e)&&e!==t&&y(p,e,{get:()=>r[e],enumerable:!(s=P(r,e))||s.enumerable});return p};var c=p=>S(y({},"__esModule",{value:!0}),p);var d={};h(d,{ClientOnly:()=>o.ClientOnly,Dynamic:()=>o.Dynamic,ErrorBoundary:()=>o.ErrorBoundary,For:()=>o.For,Index:()=>o.Index,Match:()=>o.Match,NoSsr:()=>o.NoSsr,Portal:()=>o.Portal,Show:()=>o.Show,Switch:()=>o.Switch});module.exports=c(d);var o=require("@fluixi/dom");
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/control-flow.ts
+var control_flow_exports = {};
+__export(control_flow_exports, {
+  ClientOnly: () => import_dom.ClientOnly,
+  Dynamic: () => import_dom.Dynamic,
+  ErrorBoundary: () => import_dom.ErrorBoundary,
+  For: () => import_dom.For,
+  Index: () => import_dom.Index,
+  Match: () => import_dom.Match,
+  NoSsr: () => import_dom.NoSsr,
+  Portal: () => import_dom.Portal,
+  Show: () => import_dom.Show,
+  Switch: () => import_dom.Switch
+});
+module.exports = __toCommonJS(control_flow_exports);
+var import_dom = require("@fluixi/dom");