sibujs 1.0.0-beta.1

package/dist/patterns.cjs

@@ -0,0 +1,815 @@
+"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);
+
+// patterns.ts
+var patterns_exports = {};
+__export(patterns_exports, {
+  RenderProp: () => RenderProp,
+  assertType: () => assertType,
+  composable: () => composable,
+  compose: () => compose,
+  createEffect: () => createEffect,
+  createGuard: () => createGuard,
+  createMemo: () => createMemo,
+  createSignal: () => createSignal,
+  createSlots: () => createSlots,
+  defineComponent: () => defineComponent,
+  defineSlottedComponent: () => defineSlottedComponent,
+  defineStrictComponent: () => defineStrictComponent,
+  globalStore: () => globalStore,
+  machine: () => machine,
+  optimistic: () => optimistic,
+  optimisticList: () => optimisticList,
+  persisted: () => persisted,
+  timeline: () => timeline,
+  validateProps: () => validateProps,
+  validators: () => validators,
+  withBoundary: () => withBoundary,
+  withDefaults: () => withDefaults,
+  withProps: () => withProps,
+  withWrapper: () => withWrapper
+});
+module.exports = __toCommonJS(patterns_exports);
+
+// src/reactivity/track.ts
+var subscriberStack = [];
+var currentSubscriber = null;
+var signalSubscribers = /* @__PURE__ */ new WeakMap();
+var SUBS = "__s";
+var notifyDepth = 0;
+var pendingQueue = [];
+var pendingSet = /* @__PURE__ */ new Set();
+var suspendDepth = 0;
+var trackingSuspended = false;
+function track(effectFn, subscriber) {
+  if (!subscriber) subscriber = effectFn;
+  cleanup(subscriber);
+  subscriberStack.push(subscriber);
+  currentSubscriber = subscriber;
+  effectFn();
+  subscriberStack.pop();
+  currentSubscriber = subscriberStack[subscriberStack.length - 1] || null;
+  return () => cleanup(subscriber);
+}
+function suspendTracking() {
+  if (suspendDepth === 0) {
+    subscriberStack.push(null);
+    currentSubscriber = null;
+    trackingSuspended = true;
+  }
+  suspendDepth++;
+}
+function resumeTracking() {
+  suspendDepth--;
+  if (suspendDepth === 0) {
+    subscriberStack.pop();
+    currentSubscriber = subscriberStack[subscriberStack.length - 1] || null;
+    trackingSuspended = false;
+  }
+}
+function recordDependency(signal2) {
+  if (!currentSubscriber) return;
+  let deps = currentSubscriber._deps;
+  if (!deps) {
+    deps = /* @__PURE__ */ new Set();
+    currentSubscriber._deps = deps;
+  }
+  if (!deps.has(signal2)) {
+    deps.add(signal2);
+    let subs = signal2[SUBS];
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      signalSubscribers.set(signal2, subs);
+      signal2[SUBS] = subs;
+    }
+    subs.add(currentSubscriber);
+    if (subs.size === 1) {
+      signal2.__f = currentSubscriber;
+    } else if (signal2.__f !== void 0) {
+      signal2.__f = void 0;
+    }
+  }
+}
+function propagateDirty(sub) {
+  sub();
+  let sig = sub._sig;
+  let suspended = false;
+  if (sig && sig._g) {
+    const sDeps = sub._deps;
+    if (sDeps && sDeps.size === 1) {
+      suspendTracking();
+      suspended = true;
+      const s = sig;
+      s._d = false;
+      s._v = s._g();
+    }
+  }
+  while (sig) {
+    const first = sig.__f;
+    if (first) {
+      if (first._c) {
+        const nSig = first._sig;
+        nSig._d = true;
+        if (suspended && nSig._g) {
+          const fDeps = first._deps;
+          if (fDeps && fDeps.size === 1) {
+            nSig._d = false;
+            nSig._v = nSig._g();
+          }
+        }
+        sig = nSig;
+        continue;
+      }
+      if (!pendingSet.has(first)) {
+        pendingSet.add(first);
+        pendingQueue.push(first);
+      }
+      break;
+    }
+    const subs = sig[SUBS];
+    if (!subs) break;
+    let nextSig;
+    for (const s of subs) {
+      if (s._c) {
+        s();
+        const nSig = s._sig;
+        if (nSig && !nextSig) {
+          nextSig = nSig;
+        } else if (nSig) {
+          propagateDirty(s);
+        }
+      } else if (!pendingSet.has(s)) {
+        pendingSet.add(s);
+        pendingQueue.push(s);
+      }
+    }
+    sig = nextSig;
+  }
+  if (suspended) resumeTracking();
+}
+function notifySubscribers(signal2) {
+  const first = signal2.__f;
+  if (first) {
+    if (notifyDepth > 0) {
+      if (first._c) {
+        propagateDirty(first);
+      } else if (!pendingSet.has(first)) {
+        pendingSet.add(first);
+        pendingQueue.push(first);
+      }
+      return;
+    }
+    notifyDepth++;
+    try {
+      if (first._c) {
+        propagateDirty(first);
+      } else {
+        first();
+      }
+      let i = 0;
+      while (i < pendingQueue.length) {
+        pendingQueue[i]();
+        i++;
+      }
+    } finally {
+      pendingQueue.length = 0;
+      pendingSet.clear();
+      notifyDepth--;
+    }
+    return;
+  }
+  const subs = signal2[SUBS];
+  if (!subs || subs.size === 0) return;
+  if (notifyDepth > 0) {
+    for (const sub of subs) {
+      if (sub._c) {
+        propagateDirty(sub);
+      } else if (!pendingSet.has(sub)) {
+        pendingSet.add(sub);
+        pendingQueue.push(sub);
+      }
+    }
+    return;
+  }
+  notifyDepth++;
+  try {
+    let directCount = 0;
+    for (const sub of subs) {
+      pendingQueue[directCount++] = sub;
+    }
+    for (let i2 = 0; i2 < directCount; i2++) {
+      if (pendingQueue[i2]._c) {
+        propagateDirty(pendingQueue[i2]);
+      }
+    }
+    for (let i2 = 0; i2 < directCount; i2++) {
+      if (!pendingQueue[i2]._c) {
+        if (!pendingSet.has(pendingQueue[i2])) {
+          pendingQueue[i2]();
+        }
+      }
+    }
+    let i = directCount;
+    while (i < pendingQueue.length) {
+      pendingQueue[i]();
+      i++;
+    }
+  } finally {
+    pendingQueue.length = 0;
+    pendingSet.clear();
+    notifyDepth--;
+  }
+}
+function cleanup(subscriber) {
+  const deps = subscriber._deps;
+  if (!deps || deps.size === 0) return;
+  for (const signal2 of deps) {
+    const subs = signal2[SUBS];
+    if (subs) {
+      subs.delete(subscriber);
+      if (signal2.__f === subscriber) {
+        signal2.__f = void 0;
+      }
+    }
+  }
+  deps.clear();
+}
+
+// src/reactivity/batch.ts
+var batchDepth = 0;
+var pendingSignals = /* @__PURE__ */ new Set();
+function enqueueBatchedSignal(signal2) {
+  if (batchDepth === 0) return false;
+  pendingSignals.add(signal2);
+  return true;
+}
+
+// src/core/signals/signal.ts
+function signal(initial, options) {
+  const state = { value: initial };
+  const debugName = options?.name;
+  if (debugName) {
+    state.__name = debugName;
+  }
+  function get() {
+    recordDependency(state);
+    return state.value;
+  }
+  get.__signal = state;
+  if (debugName) get.__name = debugName;
+  function set(next) {
+    const newValue = typeof next === "function" ? next(state.value) : next;
+    if (Object.is(newValue, state.value)) return;
+    const oldValue = state.value;
+    state.value = newValue;
+    const hook2 = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+    if (hook2) hook2.emit("signal:update", { signal: state, name: debugName, oldValue, newValue });
+    if (!enqueueBatchedSignal(state)) {
+      notifySubscribers(state);
+    }
+  }
+  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  if (hook) hook.emit("signal:create", { signal: state, name: debugName, getter: get, initial });
+  return [get, set];
+}
+
+// src/patterns/machine.ts
+function machine(config) {
+  const [state, setState] = signal(config.initial);
+  const [context, setContext] = signal(config.context || {});
+  const initialDef = config.states[config.initial];
+  if (initialDef?.entry) {
+    initialDef.entry(context());
+  }
+  function send(event) {
+    const currentState = state();
+    const stateDef = config.states[currentState];
+    if (!stateDef?.on) return;
+    const transition = stateDef.on[event];
+    if (!transition) return;
+    let target;
+    let guard;
+    let action;
+    if (typeof transition === "string") {
+      target = transition;
+    } else {
+      target = transition.target;
+      guard = transition.guard;
+      action = transition.action;
+    }
+    const ctx = context();
+    if (guard && !guard(ctx)) return;
+    if (stateDef.exit) {
+      stateDef.exit(ctx);
+    }
+    if (action) {
+      const patch = action(ctx);
+      setContext({ ...ctx, ...patch });
+    }
+    setState(target);
+    const targetDef = config.states[target];
+    if (targetDef?.entry) {
+      targetDef.entry(context());
+    }
+  }
+  function matches(s) {
+    return state() === s;
+  }
+  function can(event) {
+    const currentState = state();
+    const stateDef = config.states[currentState];
+    if (!stateDef?.on) return false;
+    const transition = stateDef.on[event];
+    if (!transition) return false;
+    if (typeof transition === "string") return true;
+    if (transition.guard) {
+      return transition.guard(context());
+    }
+    return true;
+  }
+  return { state, context, send, matches, can };
+}
+
+// src/core/dev.ts
+function isDev() {
+  return typeof globalThis.__SIBU_DEV__ !== "undefined" ? !!globalThis.__SIBU_DEV__ : typeof __SIBU_DEV__ !== "undefined" ? __SIBU_DEV__ : true;
+}
+function devAssert(condition, message) {
+  if (isDev() && !condition) {
+    throw new Error(`[Sibu] ${message}`);
+  }
+}
+
+// src/core/ssr-context.ts
+var ssrMode = false;
+function isSSR() {
+  return ssrMode;
+}
+
+// src/core/signals/effect.ts
+function effect(effectFn) {
+  devAssert(typeof effectFn === "function", "effect: argument must be a function.");
+  if (isSSR()) return () => {
+  };
+  let runCount = 0;
+  let cleanupHandle = () => {
+  };
+  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  const subscriber = () => {
+    cleanupHandle();
+    runCount++;
+    if (hook) hook.emit("effect:run", { effectFn, runCount });
+    cleanupHandle = track(effectFn, subscriber);
+  };
+  cleanupHandle = track(effectFn, subscriber);
+  runCount = 1;
+  if (hook) hook.emit("effect:create", { effectFn });
+  return () => {
+    if (hook) hook.emit("effect:destroy", { effectFn });
+    cleanupHandle();
+  };
+}
+
+// src/patterns/persist.ts
+function persisted(key, initial, options = {}) {
+  const storage = options.session ? sessionStorage : localStorage;
+  const serialize = options.serialize || JSON.stringify;
+  const deserialize = options.deserialize || JSON.parse;
+  let restored = initial;
+  try {
+    const raw = storage.getItem(key);
+    if (raw !== null) {
+      const parsed = deserialize(raw);
+      restored = options.validate && !options.validate(parsed) ? initial : parsed;
+    }
+  } catch {
+  }
+  const [value, setValue] = signal(restored);
+  effect(() => {
+    const current = value();
+    try {
+      storage.setItem(key, serialize(current));
+    } catch {
+    }
+  });
+  return [value, setValue];
+}
+
+// src/patterns/optimistic.ts
+function optimistic(initialValue) {
+  const [value, setValue] = signal(initialValue);
+  const [_pending, setPending] = signal(false);
+  async function addOptimistic(optimisticValue, asyncAction) {
+    const previousValue = value();
+    setValue(optimisticValue);
+    setPending(true);
+    try {
+      const result = await asyncAction();
+      setValue(result);
+    } catch {
+      setValue(previousValue);
+    } finally {
+      setPending(false);
+    }
+  }
+  return [value, addOptimistic];
+}
+function optimisticList(initialValue) {
+  const [items, setItems] = signal([...initialValue]);
+  async function addOptimistic(item, asyncAction) {
+    const prev = items();
+    setItems([...prev, item]);
+    try {
+      const result = await asyncAction();
+      setItems([...prev, result]);
+    } catch {
+      setItems(prev);
+    }
+  }
+  async function removeOptimistic(predicate, asyncAction) {
+    const prev = items();
+    setItems(prev.filter((item) => !predicate(item)));
+    try {
+      await asyncAction();
+    } catch {
+      setItems(prev);
+    }
+  }
+  async function updateOptimistic(predicate, update, asyncAction) {
+    const prev = items();
+    setItems(prev.map((item) => predicate(item) ? { ...item, ...update } : item));
+    try {
+      const result = await asyncAction();
+      setItems(prev.map((item) => predicate(item) ? result : item));
+    } catch {
+      setItems(prev);
+    }
+  }
+  return { items, addOptimistic, removeOptimistic, updateOptimistic };
+}
+
+// src/core/signals/derived.ts
+function derived(getter, options) {
+  devAssert(typeof getter === "function", "derived: argument must be a getter function.");
+  const debugName = options?.name;
+  const cs = {};
+  cs._d = false;
+  cs._g = getter;
+  const markDirty = () => {
+    if (cs._d) return;
+    cs._d = true;
+  };
+  markDirty._c = 1;
+  markDirty._sig = cs;
+  track(() => {
+    cs._d = false;
+    cs._v = getter();
+  }, markDirty);
+  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  function computedGetter() {
+    if (trackingSuspended) {
+      if (cs._d) {
+        cs._d = false;
+        cs._v = getter();
+      }
+      return cs._v;
+    }
+    recordDependency(cs);
+    if (cs._d) {
+      const oldValue = cs._v;
+      cs._d = false;
+      suspendTracking();
+      try {
+        cs._v = getter();
+      } finally {
+        resumeTracking();
+      }
+      if (hook && oldValue !== cs._v) {
+        hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
+      }
+    }
+    return cs._v;
+  }
+  if (debugName) {
+    computedGetter.__name = debugName;
+    cs.__name = debugName;
+  }
+  computedGetter.__signal = cs;
+  if (hook) hook.emit("computed:create", { signal: cs, name: debugName, getter: computedGetter });
+  return computedGetter;
+}
+
+// src/patterns/timeTravel.ts
+function timeline(initial, maxHistory = 100) {
+  const [history, setHistory] = signal([initial]);
+  const [index, setIndex] = signal(0);
+  const value = derived(() => history()[index()]);
+  const canUndo = derived(() => index() > 0);
+  const canRedo = derived(() => index() < history().length - 1);
+  function set(next) {
+    const current = value();
+    const newValue = typeof next === "function" ? next(current) : next;
+    if (Object.is(newValue, current)) return;
+    const hist = history();
+    const idx = index();
+    const newHistory = hist.slice(0, idx + 1);
+    newHistory.push(newValue);
+    if (newHistory.length > maxHistory) {
+      newHistory.shift();
+      setHistory(newHistory);
+      setIndex(newHistory.length - 1);
+    } else {
+      setHistory(newHistory);
+      setIndex(idx + 1);
+    }
+  }
+  function undo() {
+    if (canUndo()) {
+      setIndex(index() - 1);
+    }
+  }
+  function redo() {
+    if (canRedo()) {
+      setIndex(index() + 1);
+    }
+  }
+  function reset() {
+    setHistory([initial]);
+    setIndex(0);
+  }
+  function jumpTo(targetIndex) {
+    const hist = history();
+    if (targetIndex >= 0 && targetIndex < hist.length) {
+      setIndex(targetIndex);
+    }
+  }
+  return { value, set, undo, redo, canUndo, canRedo, history, index, reset, jumpTo };
+}
+
+// src/patterns/globalStore.ts
+function globalStore(config) {
+  const initialState = { ...config.state };
+  const [getState, setState] = signal({ ...initialState });
+  const listeners = /* @__PURE__ */ new Set();
+  const middlewares = config.middleware || [];
+  function dispatch(action, payload) {
+    const actionFn = config.actions[action];
+    if (!actionFn) throw new Error(`Unknown action: ${String(action)}`);
+    const execute = () => {
+      const current = getState();
+      const patch = actionFn(current, payload);
+      setState({ ...current, ...patch });
+      const newState = getState();
+      for (const listener of listeners) {
+        listener(newState);
+      }
+    };
+    if (middlewares.length === 0) {
+      execute();
+      return;
+    }
+    let index = 0;
+    const next = () => {
+      if (index < middlewares.length) {
+        const mw = middlewares[index++];
+        mw(getState(), String(action), payload, next);
+      } else {
+        execute();
+      }
+    };
+    next();
+  }
+  function select(selector) {
+    return derived(() => selector(getState()));
+  }
+  function subscribe(callback) {
+    listeners.add(callback);
+    return () => listeners.delete(callback);
+  }
+  function reset() {
+    setState({ ...initialState });
+    for (const listener of listeners) {
+      listener(getState());
+    }
+  }
+  return { getState, select, dispatch, subscribe, reset };
+}
+
+// src/patterns/primitives.ts
+function createSignal(value) {
+  return signal(value);
+}
+function createMemo(fn) {
+  return derived(fn);
+}
+function createEffect(fn) {
+  return effect(fn);
+}
+
+// src/patterns/hoc.ts
+function withWrapper(WrappedComponent, wrapper) {
+  return (props) => wrapper(WrappedComponent, props);
+}
+function withDefaults(component, defaults) {
+  return (props) => component({ ...defaults, ...props });
+}
+function compose(...wrappers) {
+  return (component) => wrappers.reduceRight((comp, wrapper) => wrapper(comp), component);
+}
+
+// src/patterns/composable.ts
+function composable(setup) {
+  return setup;
+}
+function RenderProp(props) {
+  return props.render(props.data());
+}
+function withBoundary(name, component) {
+  return (props) => {
+    const wrapper = document.createElement("div");
+    wrapper.setAttribute("data-sibu-boundary", name);
+    try {
+      const el = component(props);
+      wrapper.appendChild(el);
+    } catch (error) {
+      const errorEl = document.createElement("div");
+      errorEl.setAttribute("data-sibu-boundary-error", name);
+      errorEl.style.cssText = "color: red; border: 1px solid red; padding: 8px; margin: 4px;";
+      errorEl.textContent = `[${name}] ${error instanceof Error ? error.message : String(error)}`;
+      wrapper.appendChild(errorEl);
+    }
+    return wrapper;
+  };
+}
+function createSlots(slots) {
+  return {
+    renderSlot(name, fallback) {
+      const slotFn = slots[name];
+      if (slotFn) {
+        const result = slotFn();
+        if (Array.isArray(result)) {
+          const fragment = document.createElement("div");
+          fragment.style.display = "contents";
+          for (const el of result) fragment.appendChild(el);
+          return fragment;
+        }
+        return result;
+      }
+      return fallback ? fallback() : null;
+    },
+    hasSlot(name) {
+      return name in slots;
+    }
+  };
+}
+
+// src/patterns/componentProps.ts
+function defineComponent(config) {
+  const { defaults, setup } = config;
+  return (props) => {
+    const merged = defaults ? { ...defaults, ...props } : props;
+    return setup(merged);
+  };
+}
+function defineSlottedComponent(config) {
+  const { defaults, setup } = config;
+  return (props) => {
+    const merged = defaults ? { ...defaults, ...props } : props;
+    return setup(merged);
+  };
+}
+function withProps(component, mapProps) {
+  return (props) => component(mapProps(props));
+}
+
+// src/patterns/contracts.ts
+var validators = {
+  string: ((value, name) => typeof value === "string" || `${name} must be a string, got ${typeof value}`),
+  number: ((value, name) => typeof value === "number" || `${name} must be a number, got ${typeof value}`),
+  boolean: ((value, name) => typeof value === "boolean" || `${name} must be a boolean, got ${typeof value}`),
+  function: ((value, name) => typeof value === "function" || `${name} must be a function, got ${typeof value}`),
+  object: ((value, name) => typeof value === "object" && value !== null || `${name} must be an object`),
+  array: ((value, name) => Array.isArray(value) || `${name} must be an array`),
+  required: ((value, name) => value != null || `${name} is required`),
+  oneOf: (...values) => (value, name) => values.includes(value) || `${name} must be one of: ${values.join(", ")}`,
+  instanceOf: (ctor) => (value, name) => value instanceof ctor || `${name} must be an instance of ${ctor.name}`,
+  arrayOf: (itemValidator) => (value, name) => {
+    if (!Array.isArray(value)) return `${name} must be an array`;
+    for (let i = 0; i < value.length; i++) {
+      const result = itemValidator(value[i], `${name}[${i}]`);
+      if (result !== true) return result;
+    }
+    return true;
+  },
+  shape: (schema) => (value, name) => {
+    if (typeof value !== "object" || value === null) return `${name} must be an object`;
+    for (const [key, validator] of Object.entries(schema)) {
+      const result = validator(value[key], `${name}.${key}`);
+      if (result !== true) return result;
+    }
+    return true;
+  },
+  optional: (validator) => (value, name) => {
+    if (value == null) return true;
+    return validator(value, name);
+  },
+  range: (min, max) => (value, name) => {
+    if (typeof value !== "number") return `${name} must be a number`;
+    return value >= min && value <= max || `${name} must be between ${min} and ${max}`;
+  },
+  pattern: (regex) => (value, name) => {
+    if (typeof value !== "string") return `${name} must be a string`;
+    return regex.test(value) || `${name} must match pattern ${regex}`;
+  }
+};
+function validateProps(props, schema) {
+  const result = { ...props };
+  const errors = [];
+  const isDev2 = typeof process === "undefined" || process?.env?.NODE_ENV !== "production";
+  for (const [key, def] of Object.entries(schema)) {
+    const propDef = typeof def === "function" ? { type: def } : def;
+    if (result[key] == null && propDef.default !== void 0) {
+      result[key] = typeof propDef.default === "function" ? propDef.default() : propDef.default;
+    }
+    if (!isDev2) continue;
+    if (propDef.required && result[key] == null) {
+      errors.push(`Prop '${key}' is required`);
+      continue;
+    }
+    if (result[key] == null) continue;
+    if (propDef.type) {
+      const typeResult = propDef.type(result[key], key);
+      if (typeResult !== true) errors.push(typeResult);
+    }
+    if (propDef.validator) {
+      const validResult = propDef.validator(result[key], key);
+      if (validResult !== true) errors.push(validResult);
+    }
+  }
+  if (errors.length > 0 && isDev2) {
+    console.warn(`[SibuJS] Prop validation errors:
+${errors.map((e) => `  - ${e}`).join("\n")}`);
+  }
+  return result;
+}
+function defineStrictComponent(config) {
+  return (props) => {
+    const validated = validateProps(props, config.props);
+    return config.setup(validated);
+  };
+}
+function assertType(value, validator, label) {
+  if (typeof process !== "undefined" && process?.env?.NODE_ENV === "production") return;
+  const result = validator(value, label || "value");
+  if (result !== true) {
+    throw new TypeError(`[SibuJS Contract] ${result}`);
+  }
+}
+function createGuard(validator) {
+  return (value) => {
+    return validator(value, "value") === true;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RenderProp,
+  assertType,
+  composable,
+  compose,
+  createEffect,
+  createGuard,
+  createMemo,
+  createSignal,
+  createSlots,
+  defineComponent,
+  defineSlottedComponent,
+  defineStrictComponent,
+  globalStore,
+  machine,
+  optimistic,
+  optimisticList,
+  persisted,
+  timeline,
+  validateProps,
+  validators,
+  withBoundary,
+  withDefaults,
+  withProps,
+  withWrapper
+});