@epoch32/visage 1.1.3 → 1.1.5

package/dist/index-2zz0g2n2.js

@@ -0,0 +1,212 @@
+// src/form/schema.ts
+class Schema2 {
+  "~standard" = {
+    version: 1,
+    vendor: "visage",
+    validate: (val) => {
+      const res = this.validate(val);
+      if (res.success) {
+        return { value: res.data };
+      }
+      return {
+        issues: (res.issues || []).map((i) => ({
+          path: [i.path],
+          message: i.message
+        }))
+      };
+    }
+  };
+}
+
+class StringSchema extends Schema2 {
+  _min;
+  _max;
+  _emailMsg;
+  _regex;
+  _isOptional = false;
+  min(length, message) {
+    this._min = { val: length, msg: message };
+    return this;
+  }
+  max(length, message) {
+    this._max = { val: length, msg: message };
+    return this;
+  }
+  email(message) {
+    this._emailMsg = message ?? "Invalid email address";
+    return this;
+  }
+  regex(pattern, message) {
+    this._regex = { pattern, msg: message };
+    return this;
+  }
+  optional() {
+    this._isOptional = true;
+    return this;
+  }
+  validate(value, path = "") {
+    if (value === undefined || value === null || value === "") {
+      if (this._isOptional)
+        return { success: true, data: undefined };
+      return { success: false, issues: [{ path, message: "This field is required" }] };
+    }
+    if (typeof value !== "string") {
+      return { success: false, issues: [{ path, message: "Must be a string" }] };
+    }
+    if (this._min && value.length < this._min.val) {
+      return {
+        success: false,
+        issues: [{ path, message: this._min.msg ?? `Must be at least ${this._min.val} characters` }]
+      };
+    }
+    if (this._max && value.length > this._max.val) {
+      return {
+        success: false,
+        issues: [{ path, message: this._max.msg ?? `Must be at most ${this._max.val} characters` }]
+      };
+    }
+    if (this._emailMsg) {
+      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+      if (!emailRegex.test(value)) {
+        return { success: false, issues: [{ path, message: this._emailMsg }] };
+      }
+    }
+    if (this._regex && !this._regex.pattern.test(value)) {
+      return {
+        success: false,
+        issues: [{ path, message: this._regex.msg ?? "Invalid format" }]
+      };
+    }
+    return { success: true, data: value };
+  }
+}
+
+class NumberSchema extends Schema2 {
+  _min;
+  _max;
+  _integer;
+  _isOptional = false;
+  min(value, message) {
+    this._min = { val: value, msg: message };
+    return this;
+  }
+  max(value, message) {
+    this._max = { val: value, msg: message };
+    return this;
+  }
+  integer(message) {
+    this._integer = { msg: message };
+    return this;
+  }
+  optional() {
+    this._isOptional = true;
+    return this;
+  }
+  validate(value, path = "") {
+    if (value === undefined || value === null || value === "") {
+      if (this._isOptional)
+        return { success: true, data: undefined };
+      return { success: false, issues: [{ path, message: "This field is required" }] };
+    }
+    const num = Number(value);
+    if (Number.isNaN(num) || typeof value === "boolean") {
+      return { success: false, issues: [{ path, message: "Must be a valid number" }] };
+    }
+    if (this._integer && !Number.isInteger(num)) {
+      return {
+        success: false,
+        issues: [{ path, message: this._integer.msg ?? "Must be an integer" }]
+      };
+    }
+    if (this._min && num < this._min.val) {
+      return {
+        success: false,
+        issues: [{ path, message: this._min.msg ?? `Must be at least ${this._min.val}` }]
+      };
+    }
+    if (this._max && num > this._max.val) {
+      return {
+        success: false,
+        issues: [{ path, message: this._max.msg ?? `Must be at most ${this._max.val}` }]
+      };
+    }
+    return { success: true, data: num };
+  }
+}
+
+class BooleanSchema extends Schema2 {
+  validate(value, _path = "") {
+    return { success: true, data: Boolean(value) };
+  }
+}
+
+class ObjectSchema extends Schema2 {
+  shape;
+  constructor(shape) {
+    super();
+    this.shape = shape;
+  }
+  validate(value, basePath = "") {
+    if (typeof value !== "object" || value === null) {
+      return { success: false, issues: [{ path: basePath, message: "Must be an object" }] };
+    }
+    const issues = [];
+    const data = {};
+    for (const key in this.shape) {
+      const fieldSchema = this.shape[key];
+      const fieldVal = value[key];
+      const fieldPath = basePath ? `${basePath}.${key}` : key;
+      const res = validateWithSchema2(fieldSchema, fieldVal, fieldPath);
+      if (res.success) {
+        data[key] = res.data;
+      } else if (res.issues) {
+        issues.push(...res.issues);
+      }
+    }
+    if (issues.length > 0) {
+      return { success: false, issues };
+    }
+    return { success: true, data };
+  }
+}
+function validateWithSchema2(schema, value, path = "") {
+  if (!schema)
+    return { success: true, data: value };
+  if (schema instanceof Schema2) {
+    return schema.validate(value, path);
+  }
+  if (typeof schema === "object" && "~standard" in schema) {
+    const res = schema["~standard"].validate(value);
+    if ("value" in res) {
+      return { success: true, data: res.value };
+    }
+    return {
+      success: false,
+      issues: res.issues.map((i) => ({
+        path: i.path ? i.path.join(".") : path,
+        message: i.message
+      }))
+    };
+  }
+  if (typeof schema === "function") {
+    const res = schema(value);
+    if (res === true || res === null || res === undefined) {
+      return { success: true, data: value };
+    }
+    if (typeof res === "string") {
+      return { success: false, issues: [{ path, message: res }] };
+    }
+    if (typeof res === "object") {
+      return res;
+    }
+  }
+  return { success: true, data: value };
+}
+var v2 = {
+  string: () => new StringSchema,
+  number: () => new NumberSchema,
+  boolean: () => new BooleanSchema,
+  object: (shape) => new ObjectSchema(shape)
+};
+
+export { Schema2, validateWithSchema2, v2 };

package/dist/index-5s255b3w.js

@@ -0,0 +1,303 @@
+import {
+  untrack2,
+  resolveValue2,
+  insertChild2,
+  Scope2,
+  onCleanup2,
+  runInScope2,
+  getActiveScope2,
+  useContext2,
+  effect2
+} from "./index-6kfe1nr4.js";
+import {
+  SuspenseContext2,
+  createResource2
+} from "./index-a4xns6cc.js";
+
+// src/dom/lazy.ts
+function lazy2(importer) {
+  let loadedComponent = null;
+  let loadingPromise = null;
+  const preload = () => {
+    if (loadedComponent) {
+      return Promise.resolve(loadedComponent);
+    }
+    if (!loadingPromise) {
+      loadingPromise = importer().then((mod) => {
+        const comp = mod && typeof mod === "object" && "default" in mod ? mod.default : mod;
+        loadedComponent = comp;
+        return comp;
+      }).catch((err) => {
+        loadingPromise = null;
+        throw err;
+      });
+    }
+    return loadingPromise;
+  };
+  const LazyWrapper = (props) => {
+    if (loadedComponent) {
+      return loadedComponent(props);
+    }
+    const promise = preload();
+    const suspense = useContext2(SuspenseContext2);
+    if (suspense) {
+      suspense.registerPromise(promise);
+    }
+    const res = createResource2(() => promise);
+    return () => {
+      const Comp = res();
+      return Comp ? Comp(props) : null;
+    };
+  };
+  LazyWrapper.preload = preload;
+  return LazyWrapper;
+}
+// src/dom/control-flow.ts
+function Show2(props) {
+  if (typeof document === "undefined") {
+    const condition = resolveValue2(props.when);
+    if (condition) {
+      return typeof props.children === "function" && props.children.length > 0 ? props.children(() => resolveValue2(props.when)) : typeof props.children === "function" ? props.children() : props.children;
+    }
+    return props.fallback ?? null;
+  }
+  const marker = document.createComment("visage-show");
+  const initialFrag = document.createDocumentFragment();
+  initialFrag.appendChild(marker);
+  let currentScope = null;
+  let currentContent = [];
+  effect2(() => {
+    const condition = resolveValue2(props.when);
+    if (currentScope) {
+      currentScope.dispose();
+      currentScope = null;
+    }
+    for (const node of currentContent) {
+      if (node.parentNode) {
+        node.parentNode.removeChild(node);
+      }
+    }
+    currentContent = [];
+    const frag = document.createDocumentFragment();
+    if (condition) {
+      currentScope = new Scope2(getActiveScope2());
+      untrack2(() => {
+        runInScope2(currentScope, () => {
+          const childRes = typeof props.children === "function" && props.children.length > 0 ? props.children(() => resolveValue2(props.when)) : typeof props.children === "function" ? props.children() : props.children;
+          insertChild2(frag, childRes);
+        });
+      });
+    } else if (props.fallback !== undefined) {
+      currentScope = new Scope2(getActiveScope2());
+      untrack2(() => {
+        runInScope2(currentScope, () => {
+          const fallbackRes = typeof props.fallback === "function" ? props.fallback() : props.fallback;
+          insertChild2(frag, fallbackRes);
+        });
+      });
+    }
+    currentContent = Array.from(frag.childNodes);
+    const parent = marker.parentNode;
+    if (parent) {
+      parent.insertBefore(frag, marker);
+    }
+  });
+  onCleanup2(() => {
+    if (currentScope) {
+      currentScope.dispose();
+    }
+    for (const node of currentContent) {
+      if (node.parentNode) {
+        node.parentNode.removeChild(node);
+      }
+    }
+    if (marker.parentNode) {
+      marker.parentNode.removeChild(marker);
+    }
+  });
+  return initialFrag;
+}
+function For2(props) {
+  if (typeof document === "undefined") {
+    const list = resolveValue2(props.each) ?? [];
+    if (list.length === 0) {
+      return props.fallback ?? null;
+    }
+    return list.map((item, idx) => props.children(item, () => idx));
+  }
+  const marker = document.createTextNode("");
+  const initialFrag = document.createDocumentFragment();
+  let items = [];
+  let fallbackScope = null;
+  let fallbackNodes = [];
+  let isMounted = false;
+  effect2(() => {
+    const list = resolveValue2(props.each) ?? [];
+    const parent = marker.parentNode ?? (!isMounted ? initialFrag : null);
+    if (list.length === 0) {
+      for (const rec of items) {
+        rec.scope.dispose();
+        for (const node of rec.nodes) {
+          if (node.parentNode)
+            node.parentNode.removeChild(node);
+        }
+      }
+      items = [];
+      if (props.fallback !== undefined && fallbackNodes.length === 0 && parent) {
+        fallbackScope = new Scope2(getActiveScope2());
+        untrack2(() => {
+          runInScope2(fallbackScope, () => {
+            const frag = document.createDocumentFragment();
+            insertChild2(frag, props.fallback);
+            fallbackNodes = Array.from(frag.childNodes);
+            if (marker.parentNode) {
+              marker.parentNode.insertBefore(frag, marker);
+            } else if (!isMounted) {
+              initialFrag.appendChild(frag);
+            }
+          });
+        });
+      }
+      return;
+    }
+    if (fallbackNodes.length > 0) {
+      if (fallbackScope) {
+        fallbackScope.dispose();
+        fallbackScope = null;
+      }
+      for (const node of fallbackNodes) {
+        if (node.parentNode)
+          node.parentNode.removeChild(node);
+      }
+      fallbackNodes = [];
+    }
+    if (!parent)
+      return;
+    const newItems = [];
+    const prevMap = new Map;
+    for (const rec of items) {
+      prevMap.set(rec.item, rec);
+    }
+    for (let i = 0;i < list.length; i++) {
+      const item = list[i];
+      const existing = prevMap.get(item);
+      if (existing) {
+        existing.indexSignal(i);
+        newItems.push(existing);
+        prevMap.delete(item);
+      } else {
+        let indexVal = i;
+        const indexSubscribers = new Set;
+        const indexSignal = (...args) => {
+          if (args.length > 0 && args[0] !== undefined && args[0] !== indexVal) {
+            indexVal = args[0];
+            for (const sub of Array.from(indexSubscribers))
+              sub();
+          }
+          return indexVal;
+        };
+        const itemScope = new Scope2(getActiveScope2());
+        let itemNodes = [];
+        untrack2(() => {
+          runInScope2(itemScope, () => {
+            const frag = document.createDocumentFragment();
+            const child = props.children(item, indexSignal);
+            insertChild2(frag, child);
+            itemNodes = Array.from(frag.childNodes);
+          });
+        });
+        newItems.push({
+          item,
+          scope: itemScope,
+          nodes: itemNodes,
+          indexSignal
+        });
+      }
+    }
+    for (const [, removed] of prevMap) {
+      removed.scope.dispose();
+      for (const node of removed.nodes) {
+        if (node.parentNode)
+          node.parentNode.removeChild(node);
+      }
+    }
+    if (marker.parentNode) {
+      let currentMarker = marker;
+      for (let i = newItems.length - 1;i >= 0; i--) {
+        const rec = newItems[i];
+        for (let j = rec.nodes.length - 1;j >= 0; j--) {
+          const node = rec.nodes[j];
+          if (node.nextSibling !== currentMarker) {
+            marker.parentNode.insertBefore(node, currentMarker);
+          }
+          currentMarker = node;
+        }
+      }
+    } else if (!isMounted) {
+      for (const rec of newItems) {
+        for (const node of rec.nodes) {
+          initialFrag.appendChild(node);
+        }
+      }
+    }
+    items = newItems;
+  });
+  isMounted = true;
+  initialFrag.appendChild(marker);
+  onCleanup2(() => {
+    for (const rec of items) {
+      rec.scope.dispose();
+    }
+    if (fallbackScope) {
+      fallbackScope.dispose();
+    }
+  });
+  return initialFrag;
+}
+function Portal2(props) {
+  if (typeof document === "undefined") {
+    return null;
+  }
+  const marker = document.createTextNode("");
+  let currentScope = null;
+  let nodes = [];
+  effect2(() => {
+    const target = props.mount ?? (typeof document !== "undefined" ? document.body : null);
+    if (!target)
+      return;
+    if (currentScope) {
+      currentScope.dispose();
+      currentScope = null;
+    }
+    for (const node of nodes) {
+      if (node.parentNode) {
+        node.parentNode.removeChild(node);
+      }
+    }
+    nodes = [];
+    currentScope = new Scope2(getActiveScope2());
+    untrack2(() => {
+      runInScope2(currentScope, () => {
+        const childRes = typeof props.children === "function" ? props.children() : props.children;
+        const frag = document.createDocumentFragment();
+        insertChild2(frag, childRes);
+        nodes = Array.from(frag.childNodes);
+        target.appendChild(frag);
+      });
+    });
+  });
+  onCleanup2(() => {
+    if (currentScope) {
+      currentScope.dispose();
+      currentScope = null;
+    }
+    for (const node of nodes) {
+      if (node.parentNode) {
+        node.parentNode.removeChild(node);
+      }
+    }
+    nodes = [];
+  });
+  return marker;
+}
+export { lazy2, Show2, For2, Portal2 };