sibujs 1.3.0 → 1.5.0

package/dist/chunk-CNZ35WI2.js

@@ -0,0 +1,178 @@
+// 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 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 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 {
+  withWrapper,
+  withDefaults,
+  compose,
+  RenderProp,
+  withBoundary,
+  createSlots,
+  defineComponent,
+  defineSlottedComponent,
+  withProps,
+  validators,
+  validateProps,
+  defineStrictComponent,
+  assertType,
+  createGuard
+};

package/dist/chunk-GJPXRJ45.js

@@ -0,0 +1,37 @@
+import {
+  isSSR
+} from "./chunk-EUZND3CB.js";
+import {
+  track
+} from "./chunk-K4G4ZQNR.js";
+import {
+  devAssert
+} from "./chunk-5X6PP2UK.js";
+
+// src/core/signals/watch.ts
+function watch(getter, callback) {
+  devAssert(typeof getter === "function", "watch: first argument must be a getter function.");
+  devAssert(typeof callback === "function", "watch: second argument must be a callback function.");
+  if (isSSR()) return () => {
+  };
+  let oldValue;
+  let first = true;
+  const subscriber = () => {
+    const newValue = getter();
+    if (first) {
+      oldValue = newValue;
+      first = false;
+      return;
+    }
+    if (!Object.is(newValue, oldValue)) {
+      callback(newValue, oldValue);
+      oldValue = newValue;
+    }
+  };
+  const teardown = track(subscriber);
+  return teardown;
+}
+
+export {
+  watch
+};