@fluixi/core 1.0.0-alpha.100

package/dist/src/lib/index.cjs

@@ -0,0 +1,598 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/index.ts
+var index_exports = {};
+__export(index_exports, {
+  $component: () => $component,
+  ClientOnly: () => import_dom12.ClientOnly,
+  DEV: () => DEV,
+  Dynamic: () => import_dom12.Dynamic,
+  ErrorBoundary: () => import_dom12.ErrorBoundary,
+  FRAMEWORK_NAME: () => FRAMEWORK_NAME,
+  For: () => import_dom12.For,
+  Fragment: () => jsx_runtime_exports.Fragment,
+  Index: () => import_dom12.Index,
+  Match: () => import_dom12.Match,
+  NoSsr: () => import_dom12.NoSsr,
+  Portal: () => import_dom12.Portal,
+  Show: () => import_dom12.Show,
+  Store: () => import_store.Store,
+  Suspense: () => Suspense,
+  Switch: () => import_dom12.Switch,
+  VERSION: () => VERSION2,
+  addClass: () => import_dom14.addClass,
+  batch: () => import_signal9.batch,
+  classMap: () => import_dom13.classMap,
+  cleanupDelegation: () => cleanupDelegation,
+  composeProviders: () => composeProviders,
+  createComponent: () => createComponent,
+  createComputed: () => import_signal9.createComputed,
+  createContext: () => createContext3,
+  createDebounce: () => import_signal10.createDebounce,
+  createDeferred: () => import_signal9.createDeferred,
+  createEffect: () => import_signal9.createEffect,
+  createIsomorphicState: () => createIsomorphicState,
+  createMemo: () => import_signal9.createMemo,
+  createProvider: () => createProvider,
+  createRenderEffect: () => import_signal9.createRenderEffect,
+  createResource: () => import_signal9.createResource,
+  createRoot: () => import_signal9.createRoot,
+  createSelector: () => import_signal10.createSelector,
+  createSignal: () => import_signal9.createSignal,
+  createStore: () => import_store.createStore,
+  default: () => index_default,
+  delegateEvents: () => import_dom14.delegateEvents,
+  devOnly: () => devOnly,
+  getFrameworkInfo: () => getFrameworkInfo,
+  getOwner: () => import_signal9.getOwner,
+  getSharedConfig: () => getSharedConfig,
+  hydrate: () => import_dom14.hydrate,
+  initDelegation: () => initDelegation,
+  insert: () => import_dom14.insert,
+  isDOMNode: () => import_dom14.isDOMNode,
+  isDev: () => isDev,
+  isLitTemplateResult: () => import_dom14.isLitTemplateResult,
+  isRenderable: () => isRenderable,
+  jsx: () => jsx_runtime_exports.jsx,
+  jsxs: () => jsx_runtime_exports.jsxs,
+  lazy: () => lazy,
+  onCleanup: () => import_signal9.onCleanup,
+  onMount: () => onMount,
+  onUnmount: () => onUnmount,
+  portal: () => portal,
+  read: () => import_operators.readSignal,
+  reduce: () => import_operators.reduceSignal,
+  removeClass: () => import_dom14.removeClass,
+  render: () => render,
+  requireContext: () => requireContext,
+  runWithOwner: () => import_signal9.runWithOwner,
+  setAttribute: () => import_dom14.setAttribute,
+  setOwner: () => import_signal9.setOwner,
+  setProperty: () => import_dom14.setProperty,
+  spread: () => import_dom14.spread,
+  styleMap: () => import_dom13.styleMap,
+  toggleClass: () => import_dom14.toggleClass,
+  untrack: () => import_signal9.untrack,
+  untrackStore: () => import_store.untrackStore,
+  useCallback: () => useCallback,
+  useContext: () => useContext3,
+  useEffect: () => useEffect,
+  useEventListener: () => useEventListener,
+  useMemo: () => useMemo,
+  useReducer: () => useReducer,
+  useRef: () => useRef
+});
+module.exports = __toCommonJS(index_exports);
+var import_signal9 = require("@fluixi/reactive/signal");
+var import_signal10 = require("@fluixi/reactive/signal");
+var import_operators = require("@fluixi/reactive/operators");
+var import_store = require("@fluixi/reactive/store");
+
+// src/lib/render/index.ts
+var import_dom8 = require("@fluixi/dom");
+var import_signal6 = require("@fluixi/reactive/signal");
+
+// src/lib/render/versions.ts
+var import_dom = require("@fluixi/dom");
+
+// src/version.generated.ts
+var VERSION = "1.0.0-alpha.100";
+
+// src/lib/render/versions.ts
+var import_dom2 = require("@fluixi/dom");
+(0, import_dom.registerCoreVersion)(VERSION);
+
+// src/lib/render/index.ts
+var import_dom9 = require("@fluixi/dom");
+
+// src/lib/render/component.ts
+var import_dom3 = require("@fluixi/dom");
+var import_dom4 = require("@fluixi/dom");
+var import_signal = require("@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 = (0, import_signal.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 ((0, import_dom3.isServer)()) {
+    lc.mounts = [];
+    lc.effects = [];
+    return;
+  }
+  lc.scheduled = true;
+  const owner = (0, import_signal.getOwner)();
+  queueMicrotask(() => {
+    if ((0, import_signal.isOwnerDisposed)(owner)) {
+      lc.mounts = [];
+      lc.effects = [];
+      return;
+    }
+    (0, import_signal.runWithOwner)(owner, () => {
+      for (const cb of lc.mounts) {
+        try {
+          const cleanup = cb();
+          if (typeof cleanup === "function") {
+            (0, import_signal.onCleanup)(cleanup);
+          }
+        } catch (e) {
+          console.error("Error in onMount callback:", e);
+        }
+      }
+      for (const cb of lc.effects) {
+        let cleanup;
+        (0, import_signal.createEffect)(() => {
+          if (cleanup) cleanup();
+          cleanup = cb();
+        });
+        (0, import_signal.onCleanup)(() => {
+          if (cleanup) cleanup();
+        });
+      }
+      lc.mounts = [];
+      lc.effects = [];
+    });
+  });
+}
+function createComponent(Comp, props) {
+  return (0, import_dom4.createComponent)(Comp, props);
+}
+function $component(value, props) {
+  const component = typeof value === "function" ? (0, import_signal.untrack)(() => value(props)) : value;
+  const nameable = component != null && (typeof component === "function" || typeof component === "object");
+  if (nameable) {
+    try {
+      component["$name"] = value.name;
+    } catch {
+    }
+  }
+  if (nameable && !(0, import_signal.isSignal)(component)) {
+    return (0, import_dom4.asComponent)(component);
+  }
+  return component;
+}
+function onMount(fn, reactive = true) {
+  if ((0, import_dom3.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;
+    }
+    (0, import_signal.createEffect)(() => {
+      const cleanup = (0, import_signal.untrack)(fn);
+      if (typeof cleanup === "function") {
+        (0, import_signal.onCleanup)(cleanup);
+      }
+    });
+  }
+}
+function onUnmount(fn) {
+  (0, import_signal.onCleanup)(fn);
+}
+function useEffect(callback) {
+  const lc = getOwnerLifecycle();
+  if (lc) {
+    lc.effects.push(callback);
+    scheduleLifecycleFlush(lc);
+  } else {
+    let cleanup;
+    (0, import_signal.createEffect)(() => {
+      if (cleanup) cleanup();
+      cleanup = callback();
+    });
+    (0, import_signal.onCleanup)(() => {
+      if (cleanup) cleanup();
+    });
+  }
+}
+function useMemo(fn) {
+  return (0, import_signal.createMemo)(fn);
+}
+function useRef(initialValue) {
+  const ref = { current: initialValue };
+  (0, import_signal.onCleanup)(() => {
+    ref.current = null;
+  });
+  return ref;
+}
+function useReducer(reducer, initialState) {
+  const [state, setState] = (0, import_signal.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
+var import_signal2 = require("@fluixi/reactive/signal");
+var import_dom5 = require("@fluixi/dom");
+function isPromise(value) {
+  return !!(value && typeof value === "object" && typeof value.then === "function" || value instanceof Promise);
+}
+var SuspenseListContext = (0, import_signal2.createContext)(void 0, "suspense-list");
+function Suspense(props) {
+  return (0, import_dom5.createComponent)(SuspenseImpl, props);
+}
+function SuspenseImpl(props) {
+  const boundary = (0, import_signal2.createSuspenseBoundary)();
+  const listCtx = (0, import_signal2.useContext)(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" && (0, import_dom5.isComponent)(val) && !(0, import_signal2.isSignal)(val)) return val();
+    return val;
+  }
+  const fallback = (0, import_dom5.runWithoutHydration)(() => instantiateOnce(props.fallback ?? null));
+  const children = (0, import_signal2.provideSuspense)(boundary, () => (0, import_signal2.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" && (0, import_signal2.isSignal)(value)) {
+      track(value(), depth + 1);
+    }
+  };
+  (0, import_signal2.provideSuspense)(boundary, () => {
+    (0, import_signal2.createRenderEffect)(() => track(children, 0));
+  });
+  const [resolved, setResolved] = (0, import_signal2.createSignal)(void 0);
+  const childIsPromise = isPromise(children);
+  if (childIsPromise) {
+    boundary.increment();
+    children.then(
+      (v) => {
+        setResolved(() => v);
+        boundary.decrement();
+      },
+      () => boundary.decrement()
+    );
+  }
+  return (0, import_signal2.createMemo)(() => {
+    const showFallback = listState ? listState.showFallback() : boundary.inFallback();
+    if (showFallback) return fallback;
+    if (childIsPromise) return resolved();
+    return children;
+  });
+}
+(0, import_dom5.asSuspense)(Suspense);
+Object.defineProperty(Suspense, "__suspense", { value: true, enumerable: true });
+
+// src/lib/render/lazy.ts
+var import_dom6 = require("@fluixi/dom");
+var import_signal3 = require("@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((0, import_signal3.untrack)(() => C(props)));
+    }
+    if (!component) {
+      const [resource] = (0, import_signal3.createResource)(() => load(), { transport: false });
+      component = resource;
+      if (resource.error) throw resource.error;
+    }
+    return (0, import_signal3.createMemo)(() => {
+      const C = component();
+      return C ? fromChunk((0, import_dom6.createComponent)(C, props)) : void 0;
+    });
+  });
+  LazyWrapper.preload = () => load().then(() => void 0);
+  LazyWrapper.$lazy = true;
+  LazyWrapper.loader = loader;
+  return LazyWrapper;
+}
+
+// src/lib/render/deferred.ts
+var import_dom7 = require("@fluixi/dom");
+var import_signal4 = require("@fluixi/reactive/signal");
+var import_utils = require("@fluixi/dom/utils");
+
+// src/lib/render/await.ts
+var import_signal5 = require("@fluixi/reactive/signal");
+
+// src/lib/render/index.ts
+function render(code, container, options = {}) {
+  (0, import_dom9.delegateEvents)(["click", "input", "change", "submit"]);
+  if ((0, import_dom8.isServer)()) {
+    throw new Error(
+      "render() is for client-side only. Use renderToString() on server."
+    );
+  }
+  if (!container) {
+    throw new Error("Container element is required");
+  }
+  let disposer;
+  (0, import_signal6.createRoot)((dispose) => {
+    disposer = dispose;
+    const result = typeof code === "function" ? code() : code;
+    container.textContent = "";
+    (0, import_dom2.stampVersions)(container);
+    (0, import_dom2.warnOnVersionSkew)();
+    (0, import_dom9.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 ((0, import_dom9.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 ((0, import_dom8.isServer)()) return;
+  (0, import_dom9.delegateEvents)(["click", "input", "change", "submit"]);
+}
+function cleanupDelegation() {
+  if ((0, import_dom8.isServer)()) return;
+}
+
+// src/lib/context/context.ts
+var import_dom10 = require("@fluixi/dom");
+var import_signal7 = require("@fluixi/reactive/signal");
+function createContext3(defaultValue, name) {
+  const context = (0, import_signal7.createContext)(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: (0, import_dom10.asProvider)(Provider),
+    defaultValue
+  };
+}
+function useContext3(context) {
+  const value = (0, import_signal7.useContext)(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 = (0, import_signal7.getOwner)(); 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
+var import_signal8 = require("@fluixi/reactive/signal");
+var import_dom11 = require("@fluixi/dom");
+var import_storage = require("@fluixi/storage");
+var import_browser = require("@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 = (0, import_dom11.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] = (0, import_signal8.createSignal)(initial, { name: key });
+  registry().set(key, { server: options.server, set });
+  return { value, set, key };
+}
+
+// src/lib/index.ts
+var import_dom13 = require("@fluixi/dom");
+
+// src/lib/control-flow.ts
+var import_dom12 = require("@fluixi/dom");
+
+// src/lib/index.ts
+var import_dom14 = require("@fluixi/dom");
+
+// src/lib/jsx-runtime/index.ts
+var jsx_runtime_exports = {};
+__reExport(jsx_runtime_exports, require("@fluixi/jsx/jsx-runtime"));
+
+// src/lib/index.ts
+var import_signal11 = require("@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: import_signal11.createSignal,
+  createEffect: import_signal11.createEffect,
+  createMemo: import_signal11.createMemo,
+  createRoot: import_signal11.createRoot,
+  batch: import_signal11.batch,
+  untrack: import_signal11.untrack,
+  onCleanup: import_signal11.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
+};

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

@@ -0,0 +1,81 @@
+/**
+ * @module fluixi
+ *
+ * A fine-grained reactive framework following SolidJS principles:
+ * - Components execute once
+ * - Fine-grained reactivity (no VDOM)
+ * - Server-side rendering with hydration
+ * - JSX and Lit-html support
+ */
+export { createEffect, createMemo, createSignal, createResource, createRoot, createComputed, createRenderEffect, onCleanup, getOwner, runWithOwner, batch, untrack, createDeferred, setOwner, } from '@fluixi/reactive/signal';
+export { createDebounce, createSelector } from '@fluixi/reactive/signal';
+export { readSignal as read, reduceSignal as reduce, } from '@fluixi/reactive/operators';
+export type { Signal, Accessor, Setter, SignalOptions, RootOwner as Owner, Context, Resource, } from '@fluixi/reactive/signal';
+export type { ReadSignal } from '@fluixi/reactive/operators';
+export { createStore, untrackStore, Store, type StoreSetter } from '@fluixi/reactive/store';
+export { createComponent, onMount, onUnmount, lazy, useEffect, useMemo, useRef, useReducer, useEventListener, useCallback, render, portal, isRenderable, initDelegation, cleanupDelegation, Suspense, isDev, devOnly, DEV, getSharedConfig, $component, } from './render/index.js';
+export * from './context/index.js';
+export { createIsomorphicState, type IsomorphicState, type IsomorphicOptions, } from './isomorphic.js';
+import { Component, ComponentProps, LifecycleCallback, LazyComponent, RefObject, SuspenseProps } from './render/index.js';
+export type { Component, ComponentProps, LifecycleCallback, LazyComponent, RefObject, SuspenseProps, };
+export { classMap, styleMap, type ClassMapInput, type ClassCondition, type StyleMapInput, type StyleValue, } from '@fluixi/dom';
+export * from './control-flow.js';
+export { insert, spread, setAttribute, setProperty, addClass, removeClass, toggleClass, delegateEvents, isDOMNode, isLitTemplateResult, hydrate, } from '@fluixi/dom';
+export { jsx, jsxs, Fragment } from './jsx-runtime/index.js';
+export type { JSXElement } from './jsx-runtime/index.js';
+/**
+ * Framework version
+ */
+export declare const VERSION = "0.0.1";
+/**
+ * Framework name
+ */
+export declare const FRAMEWORK_NAME = "Fluixi";
+/**
+ * Get framework info
+ */
+export declare function getFrameworkInfo(): {
+    name: string;
+    version: string;
+    features: {
+        ssr: boolean;
+        hydration: boolean;
+        jsx: boolean;
+        litHtml: boolean;
+        signals: boolean;
+        fineGrained: boolean;
+        lazy: boolean;
+        hooks: boolean;
+        devMode: boolean;
+    };
+};
+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';
+import { createComponent as _createComponent, onMount as _onMount, onUnmount as _onUnmount, useEffect as _useEffect, useMemo as _useMemo, useRef as _useRef, useReducer as _useReducer, useEventListener as _useEventListener, useCallback as _useCallback } from './render/component.js';
+import { createContext as _createContext, useContext as _useContext } from './context/index.js';
+import { render as _render } from './render/index.js';
+declare const _default: {
+    createSignal: typeof _createSignal;
+    createEffect: typeof _createEffect;
+    createMemo: typeof _createMemo;
+    createRoot: typeof _createRoot;
+    batch: typeof _batch;
+    untrack: typeof _untrack;
+    onCleanup: typeof _onCleanup;
+    createContext: typeof _createContext;
+    useContext: typeof _useContext;
+    createComponent: typeof _createComponent;
+    onMount: typeof _onMount;
+    onUnmount: typeof _onUnmount;
+    useEffect: typeof _useEffect;
+    useMemo: typeof _useMemo;
+    useRef: typeof _useRef;
+    useReducer: typeof _useReducer;
+    useEventListener: typeof _useEventListener;
+    useCallback: typeof _useCallback;
+    render: typeof _render;
+    VERSION: string;
+    FRAMEWORK_NAME: string;
+    getFrameworkInfo: typeof getFrameworkInfo;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

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

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