sibujs 1.0.0-beta.1

package/dist/chunk-NSVVHQK5.js

@@ -0,0 +1,41 @@
+import {
+  notifySubscribers,
+  recordDependency,
+  track
+} from "./chunk-MZZOQHNI.js";
+
+// src/core/useEffect.ts
+function useEffect(effectFn) {
+  let cleanupHandle = () => {
+  };
+  const subscriber = () => {
+    cleanupHandle();
+    cleanupHandle = track(effectFn, subscriber);
+  };
+  cleanupHandle = track(effectFn, subscriber);
+  return () => {
+    cleanupHandle();
+  };
+}
+
+// src/core/useComputed.ts
+function useComputed(getter) {
+  let value = getter();
+  const computedSignal = {};
+  const recompute = () => {
+    const next = getter();
+    if (Object.is(next, value)) return;
+    value = next;
+    notifySubscribers(computedSignal);
+  };
+  track(recompute);
+  return function computedGetter() {
+    recordDependency(computedSignal);
+    return value;
+  };
+}
+
+export {
+  useEffect,
+  useComputed
+};

package/dist/chunk-NVI2WE7D.js

@@ -0,0 +1,443 @@
+import {
+  sbDerived
+} from "./chunk-A65GFJBL.js";
+import {
+  sbEffect
+} from "./chunk-7JOLTGUH.js";
+import {
+  sbSignal
+} from "./chunk-GBEYQRO2.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
+};

package/dist/chunk-O7QBO3PH.js

@@ -0,0 +1,58 @@
+import {
+  devAssert
+} from "./chunk-XRLFASCY.js";
+import {
+  track
+} from "./chunk-M5GNLDEO.js";
+
+// src/core/ssr-context.ts
+var ssrMode = false;
+function isSSR() {
+  return ssrMode;
+}
+function enableSSR() {
+  ssrMode = true;
+}
+function disableSSR() {
+  ssrMode = false;
+}
+function withSSR(fn) {
+  enableSSR();
+  try {
+    return fn();
+  } finally {
+    disableSSR();
+  }
+}
+
+// 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();
+  };
+}
+
+export {
+  isSSR,
+  enableSSR,
+  disableSSR,
+  withSSR,
+  effect
+};