@fluixi/core 1.0.0-alpha.100

package/dist/src/lib/index.mjs

@@ -0,0 +1,688 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
+// src/lib/index.ts
+import {
+  createEffect as createEffect3,
+  createMemo as createMemo6,
+  createSignal as createSignal5,
+  createResource as createResource4,
+  createRoot as createRoot3,
+  createComputed as createComputed2,
+  createRenderEffect as createRenderEffect3,
+  onCleanup as onCleanup2,
+  getOwner as getOwner3,
+  runWithOwner as runWithOwner2,
+  batch as batch2,
+  untrack as untrack3,
+  createDeferred as createDeferred2,
+  setOwner
+} from "@fluixi/reactive/signal";
+import { createDebounce, createSelector } from "@fluixi/reactive/signal";
+import {
+  readSignal,
+  reduceSignal
+} from "@fluixi/reactive/operators";
+import { createStore, untrackStore, Store } from "@fluixi/reactive/store";
+
+// src/lib/render/index.ts
+import { isServer as isServer3 } from "@fluixi/dom";
+import { createRoot as createRoot2 } from "@fluixi/reactive/signal";
+
+// src/lib/render/versions.ts
+import { registerCoreVersion } from "@fluixi/dom";
+
+// src/version.generated.ts
+var VERSION = "1.0.0-alpha.100";
+
+// src/lib/render/versions.ts
+import { stampVersions, warnOnVersionSkew, versions } from "@fluixi/dom";
+registerCoreVersion(VERSION);
+
+// src/lib/render/index.ts
+import {
+  isDOMNode,
+  delegateEvents,
+  insert
+} from "@fluixi/dom";
+
+// src/lib/render/component.ts
+import { isServer } from "@fluixi/dom";
+import {
+  createComponent as domCreateComponent,
+  asComponent
+} from "@fluixi/dom";
+import {
+  untrack,
+  onCleanup,
+  getOwner,
+  createEffect,
+  createMemo,
+  createSignal,
+  isSignal,
+  batch,
+  runWithOwner,
+  isOwnerDisposed
+} from "@fluixi/reactive/signal";
+var sharedConfig = {
+  context: null,
+  owner: null
+};
+function getSharedConfig() {
+  return sharedConfig;
+}
+var DEV = typeof process !== "undefined" && false;
+var _LIFECYCLE = /* @__PURE__ */ Symbol.for("fluixi-lifecycle");
+function getOwnerLifecycle() {
+  const owner = getOwner();
+  if (!owner) return null;
+  if (!owner[_LIFECYCLE]) {
+    const lc = { mounts: [], effects: [], scheduled: false };
+    owner[_LIFECYCLE] = lc;
+  }
+  return owner[_LIFECYCLE];
+}
+function scheduleLifecycleFlush(lc) {
+  if (lc.scheduled) return;
+  if (isServer()) {
+    lc.mounts = [];
+    lc.effects = [];
+    return;
+  }
+  lc.scheduled = true;
+  const owner = getOwner();
+  queueMicrotask(() => {
+    if (isOwnerDisposed(owner)) {
+      lc.mounts = [];
+      lc.effects = [];
+      return;
+    }
+    runWithOwner(owner, () => {
+      for (const cb of lc.mounts) {
+        try {
+          const cleanup = cb();
+          if (typeof cleanup === "function") {
+            onCleanup(cleanup);
+          }
+        } catch (e) {
+          console.error("Error in onMount callback:", e);
+        }
+      }
+      for (const cb of lc.effects) {
+        let cleanup;
+        createEffect(() => {
+          if (cleanup) cleanup();
+          cleanup = cb();
+        });
+        onCleanup(() => {
+          if (cleanup) cleanup();
+        });
+      }
+      lc.mounts = [];
+      lc.effects = [];
+    });
+  });
+}
+function createComponent(Comp, props) {
+  return domCreateComponent(Comp, props);
+}
+function $component(value, props) {
+  const component = typeof value === "function" ? untrack(() => value(props)) : value;
+  const nameable = component != null && (typeof component === "function" || typeof component === "object");
+  if (nameable) {
+    try {
+      component["$name"] = value.name;
+    } catch {
+    }
+  }
+  if (nameable && !isSignal(component)) {
+    return asComponent(component);
+  }
+  return component;
+}
+function onMount(fn, reactive = true) {
+  if (isServer()) return;
+  const lc = getOwnerLifecycle();
+  if (lc) {
+    if (!reactive) {
+      if (!lc.scheduled) {
+        fn();
+      }
+      return;
+    }
+    lc.mounts.push(fn);
+    scheduleLifecycleFlush(lc);
+  } else {
+    if (!reactive) {
+      fn();
+      return;
+    }
+    createEffect(() => {
+      const cleanup = untrack(fn);
+      if (typeof cleanup === "function") {
+        onCleanup(cleanup);
+      }
+    });
+  }
+}
+function onUnmount(fn) {
+  onCleanup(fn);
+}
+function useEffect(callback) {
+  const lc = getOwnerLifecycle();
+  if (lc) {
+    lc.effects.push(callback);
+    scheduleLifecycleFlush(lc);
+  } else {
+    let cleanup;
+    createEffect(() => {
+      if (cleanup) cleanup();
+      cleanup = callback();
+    });
+    onCleanup(() => {
+      if (cleanup) cleanup();
+    });
+  }
+}
+function useMemo(fn) {
+  return createMemo(fn);
+}
+function useRef(initialValue) {
+  const ref = { current: initialValue };
+  onCleanup(() => {
+    ref.current = null;
+  });
+  return ref;
+}
+function useReducer(reducer, initialState) {
+  const [state, setState] = createSignal(initialState);
+  const dispatch = (action) => {
+    setState(reducer(state(), action));
+  };
+  return [state, dispatch];
+}
+function useEventListener(target, event, handler, options) {
+  useEffect(() => {
+    const element = target && "current" in target ? target.current : target;
+    if (!element) return;
+    element.addEventListener(event, handler, options);
+    return () => {
+      element.removeEventListener(event, handler, options);
+    };
+  });
+}
+function useCallback(callback) {
+  return callback;
+}
+function isDev() {
+  return DEV;
+}
+function devOnly(fn) {
+  if (DEV) {
+    fn();
+  }
+}
+
+// src/lib/render/suspense.ts
+import {
+  createSignal as createSignal2,
+  createMemo as createMemo2,
+  createEffect as createEffect2,
+  createRenderEffect as createRenderEffect2,
+  isSignal as isSignal2,
+  readChildren,
+  useContext as useContext2,
+  createContext as createContext2,
+  createSuspenseBoundary,
+  provideSuspense
+} from "@fluixi/reactive/signal";
+import {
+  asSuspense,
+  isComponent,
+  createComponent as createComponent2,
+  runWithoutHydration
+} from "@fluixi/dom";
+function isPromise(value) {
+  return !!(value && typeof value === "object" && typeof value.then === "function" || value instanceof Promise);
+}
+var SuspenseListContext = createContext2(void 0, "suspense-list");
+function Suspense(props) {
+  return createComponent2(SuspenseImpl, props);
+}
+function SuspenseImpl(props) {
+  const boundary = createSuspenseBoundary();
+  const listCtx = useContext2(SuspenseListContext);
+  const listState = listCtx ? listCtx.register(boundary.inFallback) : void 0;
+  function instantiateOnce(val) {
+    if (val == null || typeof val === "boolean") return null;
+    if (typeof val === "function" && isComponent(val) && !isSignal2(val)) return val();
+    return val;
+  }
+  const fallback = runWithoutHydration(() => instantiateOnce(props.fallback ?? null));
+  const children = provideSuspense(boundary, () => readChildren(() => props.children));
+  const track = (value, depth) => {
+    if (depth > 8) return;
+    if (Array.isArray(value)) {
+      for (const x of value) track(x, depth + 1);
+    } else if (typeof value === "function" && isSignal2(value)) {
+      track(value(), depth + 1);
+    }
+  };
+  provideSuspense(boundary, () => {
+    createRenderEffect2(() => track(children, 0));
+  });
+  const [resolved, setResolved] = createSignal2(void 0);
+  const childIsPromise = isPromise(children);
+  if (childIsPromise) {
+    boundary.increment();
+    children.then(
+      (v) => {
+        setResolved(() => v);
+        boundary.decrement();
+      },
+      () => boundary.decrement()
+    );
+  }
+  return createMemo2(() => {
+    const showFallback = listState ? listState.showFallback() : boundary.inFallback();
+    if (showFallback) return fallback;
+    if (childIsPromise) return resolved();
+    return children;
+  });
+}
+asSuspense(Suspense);
+Object.defineProperty(Suspense, "__suspense", { value: true, enumerable: true });
+
+// src/lib/render/lazy.ts
+import { createComponent as createComponent3 } from "@fluixi/dom";
+import {
+  untrack as untrack2,
+  createMemo as createMemo3,
+  createResource as createResource2
+} from "@fluixi/reactive/signal";
+function fromChunk(value) {
+  if (value != null && (typeof value === "object" || typeof value === "function")) {
+    try {
+      value["$lazy"] = true;
+    } catch {
+    }
+  }
+  return value;
+}
+function lazy(loader, options) {
+  let resolved;
+  let promise;
+  let component;
+  function load() {
+    if (!promise) {
+      promise = loader().then((mod) => resolved = mod.default);
+    }
+    return promise;
+  }
+  if (options?.preload) load();
+  const LazyWrapper = ((props) => {
+    if (resolved) {
+      const C = resolved;
+      return fromChunk(untrack2(() => C(props)));
+    }
+    if (!component) {
+      const [resource] = createResource2(() => load(), { transport: false });
+      component = resource;
+      if (resource.error) throw resource.error;
+    }
+    return createMemo3(() => {
+      const C = component();
+      return C ? fromChunk(createComponent3(C, props)) : void 0;
+    });
+  });
+  LazyWrapper.preload = () => load().then(() => void 0);
+  LazyWrapper.$lazy = true;
+  LazyWrapper.loader = loader;
+  return LazyWrapper;
+}
+
+// src/lib/render/deferred.ts
+import { isServer as isServer2 } from "@fluixi/dom";
+import { createMemo as createMemo4, createSignal as createSignal3 } from "@fluixi/reactive/signal";
+import { observeIntersection } from "@fluixi/dom/utils";
+
+// src/lib/render/await.ts
+import { createResource as createResource3 } from "@fluixi/reactive/signal";
+
+// src/lib/render/index.ts
+function render(code, container, options = {}) {
+  delegateEvents(["click", "input", "change", "submit"]);
+  if (isServer3()) {
+    throw new Error(
+      "render() is for client-side only. Use renderToString() on server."
+    );
+  }
+  if (!container) {
+    throw new Error("Container element is required");
+  }
+  let disposer;
+  createRoot2((dispose) => {
+    disposer = dispose;
+    const result = typeof code === "function" ? code() : code;
+    container.textContent = "";
+    stampVersions(container);
+    warnOnVersionSkew();
+    insert(container, () => result);
+  });
+  return () => {
+    if (disposer) {
+      disposer();
+      disposer = void 0;
+    }
+  };
+}
+function isLitTemplateResult(value) {
+  return value && typeof value === "object" && (value["_$litType$"] !== void 0 || value["_$litDirective$"] !== void 0);
+}
+function portal(code, target, options = {}) {
+  const container = document.createElement("div");
+  container.setAttribute("data-portal", "true");
+  target.appendChild(container);
+  const dispose = render(code, container, options);
+  return () => {
+    dispose();
+    if (target.contains(container)) {
+      target.removeChild(container);
+    }
+  };
+}
+function isRenderable(value) {
+  if (value == null) return true;
+  if (typeof value === "function") return true;
+  if (isDOMNode(value)) return true;
+  if (isLitTemplateResult(value)) return true;
+  if (Array.isArray(value)) return true;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return true;
+  }
+  return false;
+}
+function initDelegation() {
+  if (isServer3()) return;
+  delegateEvents(["click", "input", "change", "submit"]);
+}
+function cleanupDelegation() {
+  if (isServer3()) return;
+}
+
+// src/lib/context/context.ts
+import { asProvider } from "@fluixi/dom";
+import {
+  createContext as createReactiveContext,
+  getOwner as getOwner2,
+  useContext as useReactiveContext
+} from "@fluixi/reactive/signal";
+function createContext3(defaultValue, name) {
+  const context = createReactiveContext(defaultValue, name);
+  const Provider = (props) => (
+    // Children stay a getter: the reactive Provider reads them after stamping the value on
+    // its owner. Reading `props.children` here would render them, and any <Outlet/> in them,
+    // before the context exists.
+    context.Provider({
+      value: props.value,
+      get children() {
+        return props.children;
+      },
+      debug: props.debug
+    })
+  );
+  return {
+    id: context.id,
+    Provider: asProvider(Provider),
+    defaultValue
+  };
+}
+function useContext3(context) {
+  const value = useReactiveContext(context);
+  return value !== void 0 ? value : context.defaultValue;
+}
+function createProvider(context, value, props) {
+  const resolved = typeof value === "function" ? value() : value;
+  return context.Provider({
+    value: resolved,
+    get children() {
+      return props.children;
+    }
+  });
+}
+function composeProviders(providers, props) {
+  const outermost = providers.reduceRight(
+    (inner, [context, value]) => ({
+      get children() {
+        return createProvider(context, value, inner);
+      }
+    }),
+    props
+  );
+  return outermost.children;
+}
+function requireContext(context, message) {
+  for (let owner = getOwner2(); owner; owner = owner.parent) {
+    if (owner.contexts?.has(context.id)) return useContext3(context);
+  }
+  throw new Error(message ?? `[fluixi] No Provider for ${context.id.description ?? "this context"} above this component.`);
+}
+
+// src/lib/isomorphic.ts
+import { createSignal as createSignal4, createMemo as createMemo5 } from "@fluixi/reactive/signal";
+import { getServerData } from "@fluixi/dom";
+import { createSyncStorage } from "@fluixi/storage";
+import { localStorageAdapter } from "@fluixi/storage/browser";
+var REGISTRY_KEY = "__fluixi_iso_states__";
+var SEED_PREFIX = "__iso:";
+function registry() {
+  return globalThis[REGISTRY_KEY] ??= /* @__PURE__ */ new Map();
+}
+function readSeed(key) {
+  if (typeof window === "undefined") return void 0;
+  const data = getServerData();
+  return data ? data[SEED_PREFIX + key] : void 0;
+}
+function createIsomorphicState(key, options) {
+  const seed = readSeed(key);
+  const initial = seed !== void 0 ? seed : typeof window !== "undefined" && options.client ? options.client() : options.fallback;
+  const [value, set] = createSignal4(initial, { name: key });
+  registry().set(key, { server: options.server, set });
+  return { value, set, key };
+}
+
+// src/lib/index.ts
+import {
+  classMap,
+  styleMap
+} from "@fluixi/dom";
+
+// src/lib/control-flow.ts
+import {
+  Show,
+  For,
+  Index,
+  Switch,
+  Match,
+  Dynamic,
+  ErrorBoundary,
+  Portal,
+  ClientOnly,
+  NoSsr
+} from "@fluixi/dom";
+
+// src/lib/index.ts
+import {
+  insert as insert2,
+  spread,
+  setAttribute,
+  setProperty,
+  addClass,
+  removeClass,
+  toggleClass,
+  delegateEvents as delegateEvents2,
+  isDOMNode as isDOMNode2,
+  isLitTemplateResult as isLitTemplateResult2,
+  hydrate
+} from "@fluixi/dom";
+
+// src/lib/jsx-runtime/index.ts
+var jsx_runtime_exports = {};
+__reExport(jsx_runtime_exports, jsx_runtime_star);
+import * as jsx_runtime_star from "@fluixi/jsx/jsx-runtime";
+
+// src/lib/index.ts
+import {
+  createSignal as _createSignal,
+  createEffect as _createEffect,
+  createMemo as _createMemo,
+  createRoot as _createRoot,
+  batch as _batch,
+  untrack as _untrack,
+  onCleanup as _onCleanup
+} from "@fluixi/reactive/signal";
+var VERSION2 = "0.0.1";
+var FRAMEWORK_NAME = "Fluixi";
+function getFrameworkInfo() {
+  return {
+    name: FRAMEWORK_NAME,
+    version: VERSION2,
+    features: {
+      ssr: true,
+      hydration: true,
+      jsx: true,
+      litHtml: true,
+      signals: true,
+      fineGrained: true,
+      lazy: true,
+      hooks: true,
+      devMode: true
+    }
+  };
+}
+var index_default = {
+  // Core
+  createSignal: _createSignal,
+  createEffect: _createEffect,
+  createMemo: _createMemo,
+  createRoot: _createRoot,
+  batch: _batch,
+  untrack: _untrack,
+  onCleanup: _onCleanup,
+  // Context (from component for proper support)
+  createContext: createContext3,
+  useContext: useContext3,
+  // Components
+  createComponent,
+  onMount,
+  onUnmount,
+  // lazy: _lazy,
+  // Hooks
+  useEffect,
+  useMemo,
+  useRef,
+  useReducer,
+  useEventListener,
+  useCallback,
+  // Rendering
+  render,
+  // portal: _portal,
+  // Metadata
+  VERSION: VERSION2,
+  FRAMEWORK_NAME,
+  getFrameworkInfo
+};
+var export_Fragment = jsx_runtime_exports.Fragment;
+var export_jsx = jsx_runtime_exports.jsx;
+var export_jsxs = jsx_runtime_exports.jsxs;
+export {
+  $component,
+  ClientOnly,
+  DEV,
+  Dynamic,
+  ErrorBoundary,
+  FRAMEWORK_NAME,
+  For,
+  export_Fragment as Fragment,
+  Index,
+  Match,
+  NoSsr,
+  Portal,
+  Show,
+  Store,
+  Suspense,
+  Switch,
+  VERSION2 as VERSION,
+  addClass,
+  batch2 as batch,
+  classMap,
+  cleanupDelegation,
+  composeProviders,
+  createComponent,
+  createComputed2 as createComputed,
+  createContext3 as createContext,
+  createDebounce,
+  createDeferred2 as createDeferred,
+  createEffect3 as createEffect,
+  createIsomorphicState,
+  createMemo6 as createMemo,
+  createProvider,
+  createRenderEffect3 as createRenderEffect,
+  createResource4 as createResource,
+  createRoot3 as createRoot,
+  createSelector,
+  createSignal5 as createSignal,
+  createStore,
+  index_default as default,
+  delegateEvents2 as delegateEvents,
+  devOnly,
+  getFrameworkInfo,
+  getOwner3 as getOwner,
+  getSharedConfig,
+  hydrate,
+  initDelegation,
+  insert2 as insert,
+  isDOMNode2 as isDOMNode,
+  isDev,
+  isLitTemplateResult2 as isLitTemplateResult,
+  isRenderable,
+  export_jsx as jsx,
+  export_jsxs as jsxs,
+  lazy,
+  onCleanup2 as onCleanup,
+  onMount,
+  onUnmount,
+  portal,
+  readSignal as read,
+  reduceSignal as reduce,
+  removeClass,
+  render,
+  requireContext,
+  runWithOwner2 as runWithOwner,
+  setAttribute,
+  setOwner,
+  setProperty,
+  spread,
+  styleMap,
+  toggleClass,
+  untrack3 as untrack,
+  untrackStore,
+  useCallback,
+  useContext3 as useContext,
+  useEffect,
+  useEventListener,
+  useMemo,
+  useReducer,
+  useRef
+};