sibujs 1.0.2 → 1.0.3

package/dist/chunk-JCLGQO7T.js

@@ -1,443 +0,0 @@
-import {
-  sbDerived
-} from "./chunk-E7NGA7X2.js";
-import {
-  sbEffect
-} from "./chunk-W4OH7HG4.js";
-import {
-  sbSignal
-} from "./chunk-OB2LMD7C.js";
-
-// src/core/patterns/machine.ts
-function sbMachine(config) {
-  const [state, setState] = sbSignal(config.initial);
-  const [context, setContext] = sbSignal(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/patterns/persist.ts
-function sbPersisted(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] = sbSignal(restored);
-  sbEffect(() => {
-    const current = value();
-    try {
-      storage.setItem(key, serialize(current));
-    } catch {
-    }
-  });
-  return [value, setValue];
-}
-
-// src/core/patterns/optimistic.ts
-function sbOptimistic(initialValue) {
-  const [value, setValue] = sbSignal(initialValue);
-  const [_pending, setPending] = sbSignal(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 sbOptimisticList(initialValue) {
-  const [items, setItems] = sbSignal([...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/patterns/timeTravel.ts
-function sbTimeline(initial, maxHistory = 100) {
-  const [history, setHistory] = sbSignal([initial]);
-  const [index, setIndex] = sbSignal(0);
-  const value = sbDerived(() => history()[index()]);
-  const canUndo = sbDerived(() => index() > 0);
-  const canRedo = sbDerived(() => 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/core/patterns/globalStore.ts
-function createGlobalStore(config) {
-  const initialState = { ...config.state };
-  const [getState, setState] = sbSignal({ ...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 sbDerived(() => 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/core/patterns/primitives.ts
-function createSignal(value) {
-  return sbSignal(value);
-}
-function createMemo(fn) {
-  return sbDerived(fn);
-}
-function createEffect(fn) {
-  return sbEffect(fn);
-}
-
-// src/core/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/core/patterns/composable.ts
-function createComposable(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/core/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/core/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 isDev = 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 (!isDev) 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 && isDev) {
-    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;
-  };
-}
-
-export {
-  sbMachine,
-  sbPersisted,
-  sbOptimistic,
-  sbOptimisticList,
-  sbTimeline,
-  createGlobalStore,
-  createSignal,
-  createMemo,
-  createEffect,
-  withWrapper,
-  withDefaults,
-  compose,
-  createComposable,
-  RenderProp,
-  withBoundary,
-  createSlots,
-  defineComponent,
-  defineSlottedComponent,
-  withProps,
-  validators,
-  validateProps,
-  defineStrictComponent,
-  assertType,
-  createGuard
-};