@fluixi/core 1.0.0-alpha.100

package/dist/src/lib/server/reactive.js

@@ -0,0 +1,413 @@
+/**
+ * @module @fluixi/core/server/reactive
+ *
+ * Maps reactive primitives for server-side execution
+ * Following SolidJS pattern of server-specific reactive behavior
+ *
+ * Server mode:
+ * - Signals read-only snapshot
+ * - Effects run once
+ * - No scheduling
+ * - No subscriptions
+ */
+// ============================================================================
+// SERVER SIGNAL
+// ============================================================================
+/**
+ * Server createSignal - Returns snapshot value
+ *
+ * Signals read-only snapshot on server
+ * No reactivity, no tracking, just initial value
+ *
+ * @example
+ * ```typescript
+ * // On server, this returns a static snapshot
+ * const [count, setCount] = createSignal(0);
+ * console.log(count()); // 0
+ * setCount(1); // Updates value but triggers no effects
+ * console.log(count()); // 1
+ * ```
+ */
+export function createSignal(value, options) {
+    // Server: Simple read/write, no reactivity
+    let current = value;
+    const read = (() => current);
+    const write = (newValue) => {
+        if (typeof newValue === 'function') {
+            current = newValue(current);
+        }
+        else {
+            current = newValue;
+        }
+        return current;
+    };
+    return [read, write];
+}
+// ============================================================================
+// SERVER EFFECT
+// ============================================================================
+/**
+ * Server createEffect - Runs once, no tracking
+ *
+ * Effects run once on server, no scheduling
+ * Execute immediately and return no-op disposer
+ *
+ * @example
+ * ```typescript
+ * // On server, runs once immediately
+ * createEffect(() => {
+ *   console.log('This runs once');
+ * });
+ * ```
+ */
+export function createEffect(fn, value, options) {
+    // Server: Run once, no tracking, no scheduling
+    try {
+        fn(value);
+    }
+    catch (error) {
+        console.error('[Fluixi Server] Effect error:', error);
+    }
+    // Return no-op disposer
+    return { dispose: () => { } };
+}
+// ============================================================================
+// SERVER MEMO
+// ============================================================================
+/**
+ * Server createMemo - Compute once, return static accessor
+ *
+ * No tracking on server, single evaluation
+ * Memoizes value at creation time
+ *
+ * @example
+ * ```typescript
+ * const [count] = createSignal(5);
+ * const doubled = createMemo(() => count() * 2);
+ * console.log(doubled()); // 10 (computed once)
+ * ```
+ */
+export function createMemo(fn, value, options) {
+    // Server: Compute once, no reactivity
+    const computed = fn(value);
+    return (() => computed);
+}
+// ============================================================================
+// SERVER ROOT
+// ============================================================================
+/**
+ * Server createRoot - Creates owner but no reactive tracking
+ *
+ * Owners exist on server for tree structure
+ * Needed for context and cleanup, but no reactive tracking
+ *
+ * @example
+ * ```typescript
+ * const result = createRoot((dispose) => {
+ *   // Server: Executes once, maintains owner tree
+ *   return <App />;
+ * });
+ * ```
+ */
+export function createRoot(fn) {
+    // Server: Execute function with no-op disposer
+    // Owner tree maintained for context/cleanup
+    const cleanups = [];
+    const dispose = () => {
+        cleanups.forEach((cleanup) => {
+            try {
+                cleanup();
+            }
+            catch (error) {
+                console.error('[Fluixi Server] Cleanup error:', error);
+            }
+        });
+        cleanups.length = 0;
+    };
+    try {
+        return fn(dispose);
+    }
+    catch (error) {
+        dispose();
+        throw error;
+    }
+}
+// ============================================================================
+// SERVER BATCH
+// ============================================================================
+/**
+ * Server batch - Execute immediately, no batching
+ *
+ * No scheduling on server
+ * Just runs the function synchronously
+ *
+ * @example
+ * ```typescript
+ * batch(() => {
+ *   setCount(1);
+ *   setName('Alice');
+ * }); // Executes immediately
+ * ```
+ */
+export function batch(fn) {
+    // Server: No batching needed, just run
+    return fn();
+}
+// ============================================================================
+// SERVER UNTRACK
+// ============================================================================
+/**
+ * Server untrack - Execute function (already untracked)
+ *
+ * No tracking on server anyway
+ * This is a no-op but exists for API compatibility
+ *
+ * @example
+ * ```typescript
+ * untrack(() => {
+ *   return signal(); // Not tracked (but nothing is on server)
+ * });
+ * ```
+ */
+export function untrack(fn) {
+    // Server: Already untracked, just run
+    return fn();
+}
+// ============================================================================
+// SERVER CLEANUP
+// ============================================================================
+let currentCleanups = null;
+/**
+ * Server onCleanup - Register cleanup function
+ *
+ * Cleanup still needed for SSR resource management
+ * Stores cleanup for execution when root disposes
+ *
+ * @example
+ * ```typescript
+ * createRoot((dispose) => {
+ *   onCleanup(() => {
+ *     console.log('Cleanup on dispose');
+ *   });
+ *   return result;
+ * });
+ * ```
+ */
+export function onCleanup(fn) {
+    if (currentCleanups) {
+        currentCleanups.push(fn);
+    }
+}
+// ============================================================================
+// SERVER OWNER
+// ============================================================================
+let currentOwner = null;
+/**
+ * Server getOwner - Get current reactive owner
+ *
+ * Owner tree maintained on server for context
+ */
+export function getOwner() {
+    return currentOwner;
+}
+/**
+ * Server runWithOwner - Run function with specific owner
+ *
+ * Owner switching for proper context nesting
+ */
+export function runWithOwner(owner, fn) {
+    const prev = currentOwner;
+    currentOwner = owner;
+    try {
+        return fn();
+    }
+    finally {
+        currentOwner = prev;
+    }
+}
+// ============================================================================
+// SERVER CONTEXT
+// ============================================================================
+const contextMap = new Map();
+/**
+ * Server createContext - Create context with default value
+ *
+ * Context lookup-based, no subscriptions on server
+ *
+ * @example
+ * ```typescript
+ * const ThemeContext = createContext('light');
+ * ```
+ */
+export function createContext(defaultValue) {
+    const id = Symbol('context');
+    const Provider = (props) => {
+        // Server: Store value in context map
+        const prevValue = contextMap.get(id);
+        contextMap.set(id, props.value);
+        try {
+            return props.children;
+        }
+        finally {
+            // Restore previous value
+            if (prevValue !== undefined) {
+                contextMap.set(id, prevValue);
+            }
+            else {
+                contextMap.delete(id);
+            }
+        }
+    };
+    return {
+        id,
+        Provider,
+        defaultValue: defaultValue,
+    };
+}
+/**
+ * Server useContext - Retrieve context value
+ *
+ * No subscriptions on server, just lookup
+ *
+ * @example
+ * ```typescript
+ * const theme = useContext(ThemeContext);
+ * ```
+ */
+export function useContext(context) {
+    // Server: Simple lookup, no subscription
+    const value = contextMap.get(context.id);
+    return value !== undefined ? value : context.defaultValue;
+}
+// ============================================================================
+// SERVER COMPUTED
+// ============================================================================
+/**
+ * Server createComputed - Alias for createEffect
+ *
+ * On server, computed values run once like effects
+ */
+export function createComputed(fn) {
+    return createEffect(fn);
+}
+// ============================================================================
+// SERVER RENDER EFFECT
+// ============================================================================
+/**
+ * Server createRenderEffect - Runs once for SSR rendering
+ */
+export function createRenderEffect(fn) {
+    return createEffect(fn);
+}
+// ============================================================================
+// SERVER DEFERRED
+// ============================================================================
+/**
+ * Server createDeferred - No deferring on server
+ */
+export function createDeferred(fn) {
+    return createMemo(fn);
+}
+// ============================================================================
+// SERVER SELECTOR
+// ============================================================================
+/**
+ * Server createSelector - Returns static equality check
+ */
+// ENVIRONMENT
+/**
+ * The server stand-in for `createSelector`.
+ *
+ * On the client a selector is a fine-grained membership test that only notifies the two
+ * keys whose match changed. A server render produces one pass and has no subscriptions to
+ * be fine-grained about, so this reads the source once and compares.
+ */
+export function createSelector(source) {
+    const value = source();
+    return (key) => key === value;
+}
+// ============================================================================
+// SERVER RESOURCE
+// ============================================================================
+/**
+ * Server createResource - Stub for resource creation
+ */
+export function createResource(source, fetcher, options) {
+    return [
+        () => undefined,
+        {
+            mutate: (v) => v,
+            refetch: () => { },
+        },
+    ];
+}
+/**
+ * Server createStore: plain object wrapper, no reactivity.
+ * Mirrors the client API so shared code compiles on both sides.
+ */
+export function createStore(init) {
+    const state = { ...init };
+    function setStore(keyOrPatch, value) {
+        if (typeof keyOrPatch === 'object' &&
+            keyOrPatch !== null &&
+            !Array.isArray(keyOrPatch)) {
+            for (const k of Object.keys(keyOrPatch)) {
+                const v = keyOrPatch[k];
+                state[k] = typeof v === 'function' ? v(state[k]) : v;
+            }
+        }
+        else {
+            state[keyOrPatch] =
+                typeof value === 'function' ? value(state[keyOrPatch]) : value;
+        }
+    }
+    return [state, setStore];
+}
+// ============================================================================
+// SERVER TRANSITION
+// ============================================================================
+/**
+ * Server startTransition - Execute immediately
+ */
+export function startTransition(fn) {
+    fn();
+}
+// ============================================================================
+// ENVIRONMENT
+// ============================================================================
+// ENVIRONMENT
+// ============================================================================
+/**
+ * Check if running on server
+ */
+export const isServer = true;
+/**
+ * Check if running on client
+ */
+export const isClient = false;
+// ============================================================================
+// COMPATIBILITY
+// ============================================================================
+/**
+ * Server sharedConfig - Empty config object for compatibility
+ */
+export const sharedConfig = {
+    context: null,
+    owner: null,
+};
+/**
+ * Set current reactive owner (for internal use)
+ * @internal
+ */
+export function setOwner(owner) {
+    currentOwner = owner;
+    sharedConfig.owner = owner;
+    sharedConfig.context = owner;
+}
+/**
+ * Get shared config (for compatibility)
+ * @internal
+ */
+export function getSharedConfig() {
+    return sharedConfig;
+}

package/dist/src/lib/server/reactive.mjs

@@ -0,0 +1,176 @@
+// src/lib/server/reactive.ts
+function createSignal(value, options) {
+  let current = value;
+  const read = (() => current);
+  const write = (newValue) => {
+    if (typeof newValue === "function") {
+      current = newValue(current);
+    } else {
+      current = newValue;
+    }
+    return current;
+  };
+  return [read, write];
+}
+function createEffect(fn, value, options) {
+  try {
+    fn(value);
+  } catch (error) {
+    console.error("[Fluixi Server] Effect error:", error);
+  }
+  return { dispose: () => {
+  } };
+}
+function createMemo(fn, value, options) {
+  const computed = fn(value);
+  return (() => computed);
+}
+function createRoot(fn) {
+  const cleanups = [];
+  const dispose = () => {
+    cleanups.forEach((cleanup) => {
+      try {
+        cleanup();
+      } catch (error) {
+        console.error("[Fluixi Server] Cleanup error:", error);
+      }
+    });
+    cleanups.length = 0;
+  };
+  try {
+    return fn(dispose);
+  } catch (error) {
+    dispose();
+    throw error;
+  }
+}
+function batch(fn) {
+  return fn();
+}
+function untrack(fn) {
+  return fn();
+}
+var currentCleanups = null;
+function onCleanup(fn) {
+  if (currentCleanups) {
+    currentCleanups.push(fn);
+  }
+}
+var currentOwner = null;
+function getOwner() {
+  return currentOwner;
+}
+function runWithOwner(owner, fn) {
+  const prev = currentOwner;
+  currentOwner = owner;
+  try {
+    return fn();
+  } finally {
+    currentOwner = prev;
+  }
+}
+var contextMap = /* @__PURE__ */ new Map();
+function createContext(defaultValue) {
+  const id = /* @__PURE__ */ Symbol("context");
+  const Provider = (props) => {
+    const prevValue = contextMap.get(id);
+    contextMap.set(id, props.value);
+    try {
+      return props.children;
+    } finally {
+      if (prevValue !== void 0) {
+        contextMap.set(id, prevValue);
+      } else {
+        contextMap.delete(id);
+      }
+    }
+  };
+  return {
+    id,
+    Provider,
+    defaultValue
+  };
+}
+function useContext(context) {
+  const value = contextMap.get(context.id);
+  return value !== void 0 ? value : context.defaultValue;
+}
+function createComputed(fn) {
+  return createEffect(fn);
+}
+function createRenderEffect(fn) {
+  return createEffect(fn);
+}
+function createDeferred(fn) {
+  return createMemo(fn);
+}
+function createSelector(source) {
+  const value = source();
+  return (key) => key === value;
+}
+function createResource(source, fetcher, options) {
+  return [
+    () => void 0,
+    {
+      mutate: (v) => v,
+      refetch: () => {
+      }
+    }
+  ];
+}
+function createStore(init) {
+  const state = { ...init };
+  function setStore(keyOrPatch, value) {
+    if (typeof keyOrPatch === "object" && keyOrPatch !== null && !Array.isArray(keyOrPatch)) {
+      for (const k of Object.keys(keyOrPatch)) {
+        const v = keyOrPatch[k];
+        state[k] = typeof v === "function" ? v(state[k]) : v;
+      }
+    } else {
+      state[keyOrPatch] = typeof value === "function" ? value(state[keyOrPatch]) : value;
+    }
+  }
+  return [state, setStore];
+}
+function startTransition(fn) {
+  fn();
+}
+var isServer = true;
+var isClient = false;
+var sharedConfig = {
+  context: null,
+  owner: null
+};
+function setOwner(owner) {
+  currentOwner = owner;
+  sharedConfig.owner = owner;
+  sharedConfig.context = owner;
+}
+function getSharedConfig() {
+  return sharedConfig;
+}
+export {
+  batch,
+  createComputed,
+  createContext,
+  createDeferred,
+  createEffect,
+  createMemo,
+  createRenderEffect,
+  createResource,
+  createRoot,
+  createSelector,
+  createSignal,
+  createStore,
+  getOwner,
+  getSharedConfig,
+  isClient,
+  isServer,
+  onCleanup,
+  runWithOwner,
+  setOwner,
+  sharedConfig,
+  startTransition,
+  untrack,
+  useContext
+};

package/dist/src/lib/storage/cache.cjs

@@ -0,0 +1,51 @@
+"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/storage/cache.ts
+var cache_exports = {};
+__export(cache_exports, {
+  storageCache: () => storageCache
+});
+module.exports = __toCommonJS(cache_exports);
+function storageCache(storage, options = {}) {
+  const inflight = /* @__PURE__ */ new Map();
+  return {
+    get(key) {
+      try {
+        const entry = storage.getEntry(key);
+        return entry ? { value: entry.value, timestamp: entry.createdAt } : void 0;
+      } catch {
+        return void 0;
+      }
+    },
+    set(key, entry) {
+      try {
+        storage.set(key, entry.value, options.ttl !== void 0 ? { ttl: options.ttl } : void 0);
+      } catch {
+      }
+    },
+    delete: (key) => storage.remove(key),
+    keys: () => storage.keys(),
+    clear() {
+      storage.clear();
+      inflight.clear();
+    },
+    inflight
+  };
+}

package/dist/src/lib/storage/cache.d.ts

@@ -0,0 +1,18 @@
+import type { ResourceCache } from '@fluixi/reactive/cached-resource';
+import type { TypedStorage } from '@fluixi/storage';
+/**
+ * A `cachedResource` cache kept in a storage, so fetched data outlives the page: session
+ * storage for the tab, local storage across visits. Values pass through the storage's
+ * serializer, so they must be plain data. In-flight fetches stay in memory.
+ *
+ * Give it its own namespace, since `clearCachedResources()` clears that storage, and a `ttl`
+ * so entries do not pile up after the resource that wrote them is gone.
+ *
+ * @example
+ * const cache = storageCache(useStorage({ scope: 'session', namespace: 'cache' }), { ttl: 10 * 60_000 });
+ * const orgs = cachedResource(() => api.get('/orgs'), { name: 'orgs', ttl: 60_000, cache });
+ */
+export declare function storageCache(storage: TypedStorage<any>, options?: {
+    ttl?: number;
+}): ResourceCache;
+//# sourceMappingURL=cache.d.ts.map

package/dist/src/lib/storage/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../../src/lib/storage/cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,YAAY,CAAC,GAAG,CAAC,EAAE,OAAO,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,aAAa,CA2BtG"}

package/dist/src/lib/storage/cache.js

@@ -0,0 +1,42 @@
+/**
+ * A `cachedResource` cache kept in a storage, so fetched data outlives the page: session
+ * storage for the tab, local storage across visits. Values pass through the storage's
+ * serializer, so they must be plain data. In-flight fetches stay in memory.
+ *
+ * Give it its own namespace, since `clearCachedResources()` clears that storage, and a `ttl`
+ * so entries do not pile up after the resource that wrote them is gone.
+ *
+ * @example
+ * const cache = storageCache(useStorage({ scope: 'session', namespace: 'cache' }), { ttl: 10 * 60_000 });
+ * const orgs = cachedResource(() => api.get('/orgs'), { name: 'orgs', ttl: 60_000, cache });
+ */
+export function storageCache(storage, options = {}) {
+    const inflight = new Map();
+    return {
+        get(key) {
+            try {
+                const entry = storage.getEntry(key);
+                return entry ? { value: entry.value, timestamp: entry.createdAt } : undefined;
+            }
+            catch {
+                // Unreadable or blocked: a miss, and the resource fetches.
+                return undefined;
+            }
+        },
+        set(key, entry) {
+            try {
+                storage.set(key, entry.value, options.ttl !== undefined ? { ttl: options.ttl } : undefined);
+            }
+            catch {
+                /* quota, or a value the serializer refuses: kept for this page only by the fetch itself */
+            }
+        },
+        delete: (key) => storage.remove(key),
+        keys: () => storage.keys(),
+        clear() {
+            storage.clear();
+            inflight.clear();
+        },
+        inflight,
+    };
+}