@getforma/core 0.9.1 → 1.0.0

package/dist/index.js

@@ -1,5 +1,7 @@
-import { internalEffect, createRoot, hydrateIsland, untrack, createEffect, pushSuspenseContext, popSuspenseContext, __DEV__, reportError, batch } from './chunk-CN56FSDT.js';
-export { Fragment, batch, cleanup, createEffect, createList, createMemo, createReducer, createRef, createResource, createRoot, createShow, fragment, getBatchDepth, h, hydrateIsland, isComputed, isEffect, isEffectScope, isSignal, on, onCleanup, onError, reconcileList, trigger, untrack } from './chunk-CN56FSDT.js';
+import { hydrateIsland } from './chunk-VTPFK5TJ.js';
+export { Fragment, cleanup, createList, createShow, fragment, h, hydrateIsland, reconcileList } from './chunk-VTPFK5TJ.js';
+import { internalEffect, createRoot, untrack, createEffect, pushSuspenseContext, popSuspenseContext, __DEV__, reportError, batch } from './chunk-OUVOAYIO.js';
+export { batch, createEffect, createMemo, createReducer, createRef, createResource, createRoot, getBatchDepth, isComputed, isEffect, isEffectScope, isSignal, on, onCleanup, onError, trigger, untrack } from './chunk-OUVOAYIO.js';
 import { createSignal } from './chunk-OZCHIVAZ.js';
 export { createComputed, createSignal } from './chunk-OZCHIVAZ.js';
 
@@ -236,14 +238,14 @@ function loadIslandProps(root, id, sharedProps) {
   }
   return null;
 }
-function activateIslands(registry2) {
+function activateIslands(registry) {
   const scriptBlock = document.getElementById("__forma_islands");
   const sharedProps = scriptBlock ? JSON.parse(scriptBlock.textContent) : null;
   const islands = document.querySelectorAll("[data-forma-island]");
   for (const root of islands) {
     const id = parseInt(root.getAttribute("data-forma-island"), 10);
     const componentName = root.getAttribute("data-forma-component");
-    const hydrateFn = registry2[componentName];
+    const hydrateFn = registry[componentName];
     if (!hydrateFn) {
       if (__DEV__) console.warn(`[forma] No hydrate function for island "${componentName}" (id=${id})`);
       root.setAttribute("data-forma-status", "error");
@@ -993,524 +995,6 @@ function onMutation(el, handler, options) {
   };
 }
 
-// src/storage/local.ts
-function createLocalStorage(key, options) {
-  const serialize = options?.serialize ?? JSON.stringify;
-  const deserialize = options?.deserialize ?? JSON.parse;
-  const validate = options?.validate;
-  return {
-    key,
-    get() {
-      try {
-        const raw = localStorage.getItem(key);
-        if (raw === null) return null;
-        const value = deserialize(raw);
-        if (validate && !validate(value)) return null;
-        return value;
-      } catch {
-        return null;
-      }
-    },
-    set(value) {
-      try {
-        const serialized = serialize(value);
-        localStorage.setItem(key, serialized);
-      } catch {
-      }
-    },
-    remove() {
-      localStorage.removeItem(key);
-    }
-  };
-}
-
-// src/storage/session.ts
-function createSessionStorage(key, options) {
-  const serialize = options?.serialize ?? JSON.stringify;
-  const deserialize = options?.deserialize ?? JSON.parse;
-  const validate = options?.validate;
-  return {
-    key,
-    get() {
-      try {
-        const raw = sessionStorage.getItem(key);
-        if (raw === null) return null;
-        const value = deserialize(raw);
-        if (validate && !validate(value)) return null;
-        return value;
-      } catch {
-        return null;
-      }
-    },
-    set(value) {
-      try {
-        const serialized = serialize(value);
-        sessionStorage.setItem(key, serialized);
-      } catch {
-      }
-    },
-    remove() {
-      sessionStorage.removeItem(key);
-    }
-  };
-}
-
-// src/storage/indexed.ts
-var dbCache = /* @__PURE__ */ new Map();
-function openDB(dbName, storeName) {
-  const cacheKey = `${dbName}::${storeName}`;
-  const cached = dbCache.get(cacheKey);
-  if (cached) return cached;
-  const promise = new Promise((resolve, reject) => {
-    const probe = indexedDB.open(dbName);
-    probe.onerror = () => reject(probe.error);
-    probe.onsuccess = () => {
-      const db = probe.result;
-      if (db.objectStoreNames.contains(storeName)) {
-        resolve(db);
-        return;
-      }
-      const nextVersion = db.version + 1;
-      db.close();
-      const upgrade = indexedDB.open(dbName, nextVersion);
-      upgrade.onerror = () => reject(upgrade.error);
-      upgrade.onupgradeneeded = () => {
-        const upgradedDB = upgrade.result;
-        if (!upgradedDB.objectStoreNames.contains(storeName)) {
-          upgradedDB.createObjectStore(storeName);
-        }
-      };
-      upgrade.onsuccess = () => resolve(upgrade.result);
-    };
-    probe.onupgradeneeded = () => {
-      const db = probe.result;
-      if (!db.objectStoreNames.contains(storeName)) {
-        db.createObjectStore(storeName);
-      }
-    };
-  });
-  dbCache.set(cacheKey, promise);
-  promise.catch(() => {
-    dbCache.delete(cacheKey);
-  });
-  return promise;
-}
-function createIndexedDB(dbName, storeName = "default") {
-  function withStore(mode, fn) {
-    return openDB(dbName, storeName).then(
-      (db) => new Promise((resolve, reject) => {
-        const tx = db.transaction(storeName, mode);
-        const store = tx.objectStore(storeName);
-        const request = fn(store);
-        request.onsuccess = () => resolve(request.result);
-        request.onerror = () => reject(request.error);
-      })
-    );
-  }
-  return {
-    get(key) {
-      return withStore("readonly", (store) => store.get(key));
-    },
-    set(key, value) {
-      return withStore("readwrite", (store) => store.put(value, key)).then(
-        () => void 0
-      );
-    },
-    delete(key) {
-      return withStore("readwrite", (store) => store.delete(key)).then(
-        () => void 0
-      );
-    },
-    getAll() {
-      return withStore("readonly", (store) => store.getAll());
-    },
-    keys() {
-      return withStore("readonly", (store) => store.getAllKeys()).then(
-        (keys) => keys.map(String)
-      );
-    },
-    clear() {
-      return withStore("readwrite", (store) => store.clear()).then(
-        () => void 0
-      );
-    }
-  };
-}
-
-// src/http/fetch.ts
-function createFetch(url, options) {
-  const [data, setData] = createSignal(null);
-  const [error, setError] = createSignal(null);
-  const [loading, setLoading] = createSignal(false);
-  let currentController = null;
-  function resolveURL() {
-    const raw = typeof url === "function" ? url() : url;
-    const base = options?.base ?? "";
-    const fullURL = new URL(raw, base || void 0);
-    if (options?.params) {
-      for (const [key, value] of Object.entries(options.params)) {
-        fullURL.searchParams.set(key, value);
-      }
-    }
-    return fullURL.toString();
-  }
-  async function execute() {
-    if (currentController) {
-      currentController.abort();
-    }
-    currentController = new AbortController();
-    const controller = currentController;
-    const timeoutMs = options?.timeout ?? 3e4;
-    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-    setLoading(true);
-    setError(null);
-    try {
-      const resolvedURL = resolveURL();
-      const { base: _base, params: _params, timeout: _timeout, transform, ...fetchInit } = options ?? {};
-      const response = await fetch(resolvedURL, {
-        ...fetchInit,
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-      }
-      const json = await response.json();
-      const transformed = transform ? transform(json) : json;
-      setData(transformed);
-    } catch (err) {
-      if (err instanceof Error && err.name === "AbortError") {
-        return;
-      }
-      setError(err instanceof Error ? err : new Error(String(err)));
-    } finally {
-      clearTimeout(timeoutId);
-      if (currentController === controller) {
-        currentController = null;
-        setLoading(false);
-      }
-    }
-  }
-  if (typeof url === "function") {
-    internalEffect(() => {
-      url();
-      execute();
-    });
-  } else {
-    execute();
-  }
-  return {
-    data,
-    error,
-    loading,
-    refetch: execute,
-    abort() {
-      if (currentController) {
-        currentController.abort();
-      }
-    }
-  };
-}
-async function fetchJSON(url, options) {
-  const response = await fetch(url, options);
-  if (!response.ok) {
-    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-  }
-  return await response.json();
-}
-
-// src/http/sse.ts
-function createSSE(url, options) {
-  const [data, setData] = createSignal(null);
-  const [error, setError] = createSignal(null);
-  const [connected, setConnected] = createSignal(false);
-  const source = new EventSource(url, {
-    withCredentials: options?.withCredentials ?? false
-  });
-  source.onopen = () => {
-    setConnected(true);
-    setError(null);
-  };
-  const parseMessage = options?.parse ?? ((raw) => {
-    try {
-      return JSON.parse(raw);
-    } catch {
-      return raw;
-    }
-  });
-  source.onmessage = (event) => {
-    setData(parseMessage(event.data));
-  };
-  source.onerror = (event) => {
-    setError(event);
-    setConnected(false);
-  };
-  return {
-    data,
-    error,
-    connected,
-    close() {
-      source.close();
-      setConnected(false);
-    },
-    on(event, handler) {
-      const parseEvent = options?.parse ?? ((raw) => {
-        try {
-          return JSON.parse(raw);
-        } catch {
-          return raw;
-        }
-      });
-      const listener = (e) => {
-        handler(parseEvent(e.data));
-      };
-      source.addEventListener(event, listener);
-      return () => {
-        source.removeEventListener(event, listener);
-      };
-    }
-  };
-}
-
-// src/http/ws.ts
-function createWebSocket(url, options) {
-  const shouldReconnect = options?.reconnect ?? true;
-  const baseInterval = options?.reconnectInterval ?? 1e3;
-  const maxReconnects = options?.maxReconnects ?? 5;
-  const [data, setData] = createSignal(null);
-  const [status, setStatus] = createSignal("connecting");
-  const handlers = /* @__PURE__ */ new Set();
-  let socket = null;
-  let reconnectCount = 0;
-  let reconnectTimer = null;
-  let permanentlyClosed = false;
-  function connect() {
-    if (permanentlyClosed) return;
-    setStatus("connecting");
-    socket = new WebSocket(url, options?.protocols);
-    socket.onopen = () => {
-      setStatus("open");
-      reconnectCount = 0;
-    };
-    const parseMessage = options?.parse ?? ((raw) => {
-      try {
-        return JSON.parse(raw);
-      } catch {
-        return raw;
-      }
-    });
-    socket.onmessage = (event) => {
-      const parsed = parseMessage(event.data);
-      setData(parsed);
-      for (const handler of handlers) {
-        handler(parsed);
-      }
-    };
-    socket.onerror = () => {
-      setStatus("error");
-    };
-    socket.onclose = () => {
-      if (permanentlyClosed) {
-        setStatus("closed");
-        return;
-      }
-      setStatus("closed");
-      if (shouldReconnect && reconnectCount < maxReconnects) {
-        const delay = baseInterval * Math.pow(2, reconnectCount);
-        reconnectCount++;
-        reconnectTimer = setTimeout(connect, delay);
-      }
-    };
-  }
-  connect();
-  return {
-    data,
-    status,
-    send(value) {
-      if (socket && socket.readyState === WebSocket.OPEN) {
-        socket.send(JSON.stringify(value));
-      }
-    },
-    close() {
-      permanentlyClosed = true;
-      if (reconnectTimer !== null) {
-        clearTimeout(reconnectTimer);
-        reconnectTimer = null;
-      }
-      if (socket) {
-        socket.close();
-        socket = null;
-      }
-      setStatus("closed");
-    },
-    on(handler) {
-      handlers.add(handler);
-      return () => {
-        handlers.delete(handler);
-      };
-    }
-  };
-}
-
-// src/server/action.ts
-function createAction(serverFn, options) {
-  const [pending, setPending] = createSignal(false);
-  const [error, setError] = createSignal(void 0);
-  const action = async (...args) => {
-    setPending(true);
-    setError(void 0);
-    if (options?.optimistic) {
-      try {
-        batch(() => options.optimistic(...args));
-      } catch {
-      }
-    }
-    try {
-      const result = await serverFn(...args);
-      if (options?.onSuccess) {
-        batch(() => options.onSuccess(result, ...args));
-      }
-      if (options?.invalidates) {
-        for (const resource of options.invalidates) {
-          resource.refetch();
-        }
-      }
-      setPending(false);
-      return result;
-    } catch (err) {
-      if (options?.onError) {
-        try {
-          batch(() => options.onError(err, ...args));
-        } catch {
-        }
-      }
-      setError(err);
-      setPending(false);
-      throw err;
-    }
-  };
-  const typedAction = action;
-  typedAction.pending = pending;
-  typedAction.error = error;
-  typedAction.clearError = () => setError(void 0);
-  return typedAction;
-}
-
-// src/server/mutation.ts
-var resourceRegistry = /* @__PURE__ */ new Map();
-function registerResource(key, resource) {
-  resourceRegistry.set(key, resource);
-}
-function unregisterResource(key) {
-  resourceRegistry.delete(key);
-}
-function applyRevalidation(revalidateData) {
-  for (const [key, freshData] of Object.entries(revalidateData)) {
-    const resource = resourceRegistry.get(key);
-    if (resource) {
-      resource.mutate(freshData);
-    }
-  }
-}
-function enableAutoRevalidation() {
-  if (typeof window === "undefined") {
-    return () => {
-    };
-  }
-  const handler = (event) => {
-    const detail = event.detail;
-    if (detail && typeof detail === "object") {
-      applyRevalidation(detail);
-    }
-  };
-  window.addEventListener("forma:revalidate", handler);
-  return () => window.removeEventListener("forma:revalidate", handler);
-}
-function withRevalidation(data, revalidate) {
-  return { data, __revalidate: revalidate };
-}
-
-// src/server/rpc-client.ts
-function $$serverFunction(endpoint) {
-  const rpcFn = async (...args) => {
-    const response = await fetch(endpoint, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "X-Forma-RPC": "1"
-      },
-      body: JSON.stringify({ args })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`Server function failed (${response.status}): ${errorText}`);
-    }
-    const result = await response.json();
-    if (result && typeof result === "object" && "__revalidate" in result) {
-      if (typeof window !== "undefined") {
-        window.dispatchEvent(new CustomEvent("forma:revalidate", {
-          detail: result.__revalidate
-        }));
-      }
-      return result.data;
-    }
-    return result;
-  };
-  return rpcFn;
-}
-
-// src/server/rpc-handler.ts
-var registry = /* @__PURE__ */ new Map();
-function registerServerFunction(endpoint, fn) {
-  registry.set(endpoint, fn);
-}
-function getServerFunction(endpoint) {
-  return registry.get(endpoint);
-}
-function getRegisteredEndpoints() {
-  return [...registry.keys()];
-}
-var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-async function handleRPC(endpoint, body, revalidateData) {
-  const endpointName = endpoint.split("/").pop() ?? "";
-  if (FORBIDDEN_KEYS.has(endpointName)) {
-    return { error: "Forbidden endpoint name" };
-  }
-  const fn = registry.get(endpoint);
-  if (!fn) {
-    return { error: `Unknown server function: ${endpoint}` };
-  }
-  try {
-    const result = await fn(...body.args);
-    if (revalidateData) {
-      return { data: result, __revalidate: revalidateData };
-    }
-    return { data: result };
-  } catch (err) {
-    const isDev = typeof process !== "undefined" && process.env?.NODE_ENV === "development";
-    const message = isDev && err instanceof Error ? err.message : "Internal server error";
-    return { error: message };
-  }
-}
-function createRPCMiddleware() {
-  return async (req, res) => {
-    if (req.method !== "POST") {
-      res.status(405).json({ error: "Method not allowed" });
-      return;
-    }
-    const body = req.body;
-    if (!body || !Array.isArray(body.args)) {
-      res.status(400).json({ error: "Invalid RPC request: missing args array" });
-      return;
-    }
-    const result = await handleRPC(req.url, body);
-    if (result.error) {
-      res.status(500).json(result);
-    } else {
-      res.json(result);
-    }
-  };
-}
-
-export { $, $$, $$serverFunction, activateIslands, addClass, applyRevalidation, children, closest, createAction, createBus, createContext, createErrorBoundary, createFetch, createHistory, createIndexedDB, createLocalStorage, createPortal, createRPCMiddleware, createSSE, createSessionStorage, createStore, createSuspense, createSwitch, createText, createWebSocket, deactivateAllIslands, deactivateIsland, defineComponent, delegate, disposeComponent, enableAutoRevalidation, fetchJSON, getRegisteredEndpoints, getServerFunction, handleRPC, inject, mount, nextSibling, onIntersect, onKey, onMount, onMutation, onResize, onUnmount, parent, persist, prevSibling, provide, registerResource, registerServerFunction, removeClass, setAttr, setHTML, setHTMLUnsafe, setStyle, setText, siblings, toggleClass, trackDisposer, unprovide, unregisterResource, withRevalidation };
+export { $, $$, activateIslands, addClass, children, closest, createBus, createContext, createErrorBoundary, createHistory, createPortal, createStore, createSuspense, createSwitch, createText, deactivateAllIslands, deactivateIsland, defineComponent, delegate, disposeComponent, inject, mount, nextSibling, onIntersect, onKey, onMount, onMutation, onResize, onUnmount, parent, persist, prevSibling, provide, removeClass, setAttr, setHTML, setHTMLUnsafe, setStyle, setText, siblings, toggleClass, trackDisposer, unprovide };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map