@gsc-basic/components 1.0.1 → 1.0.3

package/dist/es/node_modules/@tanstack/form-core/dist/esm/ValidationLogic.js

@@ -0,0 +1,55 @@
+const l = (a) => {
+  if (!a.validators)
+    return a.runValidation({
+      validators: [],
+      form: a.form
+    });
+  const n = a.event.async, r = n ? void 0 : { fn: a.validators.onMount, cause: "mount" }, o = {
+    fn: n ? a.validators.onChangeAsync : a.validators.onChange,
+    cause: "change"
+  }, i = {
+    fn: n ? a.validators.onBlurAsync : a.validators.onBlur,
+    cause: "blur"
+  }, e = {
+    fn: n ? a.validators.onSubmitAsync : a.validators.onSubmit,
+    cause: "submit"
+  }, t = n ? void 0 : { fn: () => {
+  }, cause: "server" };
+  switch (a.event.type) {
+    case "mount":
+      return a.runValidation({
+        validators: [r],
+        form: a.form
+      });
+    case "submit":
+      return a.runValidation({
+        validators: [
+          o,
+          i,
+          e,
+          t
+        ],
+        form: a.form
+      });
+    case "server":
+      return a.runValidation({
+        validators: [],
+        form: a.form
+      });
+    case "blur":
+      return a.runValidation({
+        validators: [i, t],
+        form: a.form
+      });
+    case "change":
+      return a.runValidation({
+        validators: [o, t],
+        form: a.form
+      });
+    default:
+      throw new Error(`Unknown validation event type: ${a.event.type}`);
+  }
+};
+export {
+  l as defaultValidationLogic
+};

package/dist/es/node_modules/@tanstack/form-core/dist/esm/metaHelper.js

@@ -0,0 +1,109 @@
+const k = {
+  isValidating: !1,
+  isTouched: !1,
+  isBlurred: !1,
+  isDirty: !1,
+  isPristine: !0,
+  isValid: !0,
+  isDefaultValue: !0,
+  errors: [],
+  errorMap: {},
+  errorSourceMap: {}
+};
+function v(u) {
+  function f(t, e, s) {
+    const r = h(t, e, "move", s), n = Math.min(e, s), c = Math.max(e, s);
+    for (let a = n; a <= c; a++)
+      r.push(o(t, a));
+    const i = Object.keys(u.fieldInfo).reduce(
+      (a, l) => (l.startsWith(o(t, e)) && a.set(
+        l,
+        u.getFieldMeta(l)
+      ), a),
+      /* @__PURE__ */ new Map()
+    );
+    F(r, e < s ? "up" : "down"), Object.keys(u.fieldInfo).filter((a) => a.startsWith(o(t, s))).forEach((a) => {
+      const l = a.replace(
+        o(t, s),
+        o(t, e)
+      ), d = i.get(l);
+      d && u.setFieldMeta(a, d);
+    });
+  }
+  function g(t, e) {
+    const s = h(t, e, "remove");
+    F(s, "up");
+  }
+  function p(t, e, s) {
+    h(t, e, "swap", s).forEach((n) => {
+      if (!n.toString().startsWith(o(t, e)))
+        return;
+      const c = n.toString().replace(
+        o(t, e),
+        o(t, s)
+      ), [i, a] = [
+        u.getFieldMeta(n),
+        u.getFieldMeta(c)
+      ];
+      i && u.setFieldMeta(c, i), a && u.setFieldMeta(n, a);
+    });
+  }
+  function w(t, e) {
+    const s = h(t, e, "insert");
+    F(s, "down"), s.forEach((r) => {
+      r.toString().startsWith(o(t, e)) && u.setFieldMeta(r, M());
+    });
+  }
+  function o(t, e) {
+    return `${t}[${e}]`;
+  }
+  function h(t, e, s, r) {
+    const n = [o(t, e)];
+    switch (s) {
+      case "swap":
+        n.push(o(t, r));
+        break;
+      case "move": {
+        const [c, i] = [
+          Math.min(e, r),
+          Math.max(e, r)
+        ];
+        for (let a = c; a <= i; a++)
+          n.push(o(t, a));
+        break;
+      }
+      default: {
+        const c = u.getFieldValue(t), i = Array.isArray(c) ? c.length : 0;
+        for (let a = e + 1; a < i; a++)
+          n.push(o(t, a));
+        break;
+      }
+    }
+    return Object.keys(u.fieldInfo).filter(
+      (c) => n.some((i) => c.startsWith(i))
+    );
+  }
+  function b(t, e) {
+    return t.replace(/\[(\d+)\]/, (s, r) => {
+      const n = parseInt(r, 10);
+      return `[${e === "up" ? n + 1 : Math.max(0, n - 1)}]`;
+    });
+  }
+  function F(t, e) {
+    (e === "up" ? t : [...t].reverse()).forEach((r) => {
+      const n = b(r.toString(), e), c = u.getFieldMeta(n);
+      c ? u.setFieldMeta(r, c) : u.setFieldMeta(r, M());
+    });
+  }
+  const M = () => k;
+  return {
+    handleArrayMove: f,
+    handleArrayRemove: g,
+    handleArraySwap: p,
+    handleArrayInsert: w
+  };
+}
+export {
+  k as defaultFieldMeta,
+  v as metaHelper
+};

package/dist/es/node_modules/@tanstack/form-core/dist/esm/standardSchemaValidator.js

@@ -0,0 +1,45 @@
+function l(s, r) {
+  const t = /* @__PURE__ */ new Map();
+  for (const e of s) {
+    const u = e.path ?? [];
+    let n = r, a = "";
+    for (let i = 0; i < u.length; i++) {
+      const o = u[i];
+      if (o === void 0) continue;
+      const c = typeof o == "object" ? o.key : o, f = Number(c);
+      Array.isArray(n) && !Number.isNaN(f) ? a += `[${f}]` : a += (i > 0 ? "." : "") + String(c), typeof n == "object" && n !== null ? n = n[c] : n = void 0;
+    }
+    t.set(a, (t.get(a) ?? []).concat(e));
+  }
+  return Object.fromEntries(t);
+}
+const d = (s, r) => {
+  const t = l(s, r);
+  return {
+    form: t,
+    fields: t
+  };
+}, m = {
+  validate({
+    value: s,
+    validationSource: r
+  }, t) {
+    const e = t["~standard"].validate(s);
+    if (e instanceof Promise)
+      throw new Error("async function passed to sync validator");
+    if (e.issues)
+      return r === "field" ? e.issues : d(e.issues, s);
+  },
+  async validateAsync({
+    value: s,
+    validationSource: r
+  }, t) {
+    const e = await t["~standard"].validate(s);
+    if (e.issues)
+      return r === "field" ? e.issues : d(e.issues, s);
+  }
+}, h = (s) => !!s && "~standard" in s;
+export {
+  h as isStandardSchemaValidator,
+  m as standardSchemaValidators
+};

package/dist/es/node_modules/@tanstack/form-core/dist/esm/utils.js

@@ -0,0 +1,213 @@
+import { liteThrottle as v } from "../../../pacer-lite/dist/lite-throttler.js";
+import { formEventClient as D } from "./EventClient.js";
+function S(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function $(e, t) {
+  return w(t).reduce((o, r) => {
+    if (o === null) return null;
+    if (typeof o < "u")
+      return o[r];
+  }, e);
+}
+function F(e, t, n) {
+  const o = w(t);
+  function r(i) {
+    if (!o.length)
+      return S(n, i);
+    const u = o.shift();
+    if (typeof u == "string" || typeof u == "number" && !Array.isArray(i))
+      return typeof i == "object" ? (i === null && (i = {}), {
+        ...i,
+        [u]: r(i[u])
+      }) : {
+        [u]: r()
+      };
+    if (Array.isArray(i) && typeof u == "number") {
+      const c = i.slice(0, u);
+      return [
+        ...c.length ? c : new Array(u),
+        r(i[u]),
+        ...i.slice(u + 1)
+      ];
+    }
+    return [...new Array(u), r()];
+  }
+  return r(e);
+}
+function T(e, t) {
+  const n = w(t);
+  function o(r) {
+    if (!r) return;
+    if (n.length === 1) {
+      const u = n[0];
+      if (Array.isArray(r) && typeof u == "number")
+        return r.filter((g, a) => a !== u);
+      const { [u]: c, ...m } = r;
+      return m;
+    }
+    const i = n.shift();
+    if ((typeof i == "string" || typeof i == "number" && !Array.isArray(r)) && typeof r == "object")
+      return {
+        ...r,
+        [i]: o(r[i])
+      };
+    if (typeof i == "number" && Array.isArray(r)) {
+      if (i >= r.length)
+        return r;
+      const u = r.slice(0, i);
+      return [
+        ...u.length ? u : new Array(i),
+        o(r[i]),
+        ...r.slice(i + 1)
+      ];
+    }
+    throw new Error("It seems we have created an infinite loop in deleteBy. ");
+  }
+  return o(e);
+}
+const A = /^(\d+)$/gm, k = /\.(\d+)(?=\.)/gm, E = /^(\d+)\./gm, p = /\.(\d+$)/gm, V = /\.{2,}/gm, h = "__int__", l = `${h}$1`;
+function w(e) {
+  if (Array.isArray(e))
+    return [...e];
+  if (typeof e != "string")
+    throw new Error("Path must be a string.");
+  return e.replace(/(^\[)|]/gm, "").replace(/\[/g, ".").replace(A, l).replace(k, `.${l}.`).replace(E, `${l}.`).replace(p, `.${l}`).replace(V, ".").split(".").map((t) => {
+    if (t.startsWith(h)) {
+      const n = t.substring(h.length), o = parseInt(n, 10);
+      return String(o) === n ? o : n;
+    }
+    return t;
+  });
+}
+function _(e) {
+  return !(Array.isArray(e) && e.length === 0);
+}
+function x(e, t) {
+  const n = (o) => o.validators.filter(Boolean).map((r) => ({
+    cause: r.cause,
+    validate: r.fn
+  }));
+  return t.validationLogic({
+    form: t.form,
+    validators: t.validators,
+    event: { type: e, async: !1 },
+    runValidation: n
+  });
+}
+function z(e, t) {
+  const { asyncDebounceMs: n } = t, {
+    onBlurAsyncDebounceMs: o,
+    onChangeAsyncDebounceMs: r,
+    onDynamicAsyncDebounceMs: i
+  } = t.validators || {}, u = n ?? 0, c = (m) => m.validators.filter(Boolean).map((g) => {
+    const a = g?.cause || e;
+    let f = u;
+    switch (a) {
+      case "change":
+        f = r ?? u;
+        break;
+      case "blur":
+        f = o ?? u;
+        break;
+      case "dynamic":
+        f = i ?? u;
+        break;
+      case "submit":
+        f = 0;
+        break;
+    }
+    return e === "submit" && (f = 0), {
+      cause: a,
+      validate: g.fn,
+      debounceMs: f
+    };
+  });
+  return t.validationLogic({
+    form: t.form,
+    validators: t.validators,
+    event: { type: e, async: !0 },
+    runValidation: c
+  });
+}
+const I = (e) => !!e && typeof e == "object" && "fields" in e;
+function M(e, t) {
+  if (Object.is(e, t))
+    return !0;
+  if (typeof e != "object" || e === null || typeof t != "object" || t === null)
+    return !1;
+  if (e instanceof Date && t instanceof Date)
+    return e.getTime() === t.getTime();
+  if (e instanceof Map && t instanceof Map) {
+    if (e.size !== t.size) return !1;
+    for (const [r, i] of e)
+      if (!t.has(r) || !Object.is(i, t.get(r))) return !1;
+    return !0;
+  }
+  if (e instanceof Set && t instanceof Set) {
+    if (e.size !== t.size) return !1;
+    for (const r of e)
+      if (!t.has(r)) return !1;
+    return !0;
+  }
+  const n = Object.keys(e), o = Object.keys(t);
+  if (n.length !== o.length)
+    return !1;
+  for (const r of n)
+    if (!o.includes(r) || !M(e[r], t[r]))
+      return !1;
+  return !0;
+}
+const P = ({
+  newFormValidatorError: e,
+  isPreviousErrorFromFormValidator: t,
+  previousErrorValue: n
+}) => e ? { newErrorValue: e, newSource: "form" } : t ? { newErrorValue: void 0, newSource: void 0 } : n ? { newErrorValue: n, newSource: "field" } : { newErrorValue: void 0, newSource: void 0 }, C = ({
+  formLevelError: e,
+  fieldLevelError: t
+}) => t ? { newErrorValue: t, newSource: "field" } : e ? { newErrorValue: e, newSource: "form" } : { newErrorValue: void 0, newSource: void 0 };
+function L(e, t) {
+  return e == null ? t : { ...e, ...t };
+}
+let s = 256;
+const d = [];
+let y;
+for (; s--; )
+  d[s] = (s + 256).toString(16).substring(1);
+function W() {
+  let e = 0, t, n = "";
+  if (!y || s + 16 > 256) {
+    for (y = new Array(256), e = 256; e--; )
+      y[e] = 256 * Math.random() | 0;
+    e = 0, s = 0;
+  }
+  for (; e < 16; e++)
+    t = y[s + e], e === 6 ? n += d[t & 15 | 64] : e === 8 ? n += d[t & 63 | 128] : n += d[t], e & 1 && e > 1 && e < 11 && (n += "-");
+  return s++, n;
+}
+const R = v(
+  (e) => D.emit("form-state", {
+    id: e.formId,
+    state: e.store.state
+  }),
+  {
+    wait: 300
+  }
+);
+export {
+  T as deleteBy,
+  C as determineFieldLevelErrorSourceAndValue,
+  P as determineFormLevelErrorSourceAndValue,
+  M as evaluate,
+  S as functionalUpdate,
+  z as getAsyncValidatorArray,
+  $ as getBy,
+  x as getSyncValidatorArray,
+  I as isGlobalFormValidationError,
+  _ as isNonEmptyArray,
+  w as makePathArray,
+  L as mergeOpts,
+  F as setBy,
+  R as throttleFormState,
+  W as uuid
+};

package/dist/es/node_modules/@tanstack/pacer-lite/dist/lite-throttler.js

@@ -0,0 +1,29 @@
+var h = class {
+  constructor(i, s) {
+    this.fn = i, this.options = s, this.lastExecutionTime = 0, this.isPending = !1, this.maybeExecute = (...t) => {
+      const e = Date.now() - this.lastExecutionTime;
+      if (this.options.leading && e >= this.options.wait) this.execute(...t);
+      else if (this.lastArgs = t, !this.timeoutId && this.options.trailing) {
+        const o = this.options.wait - e;
+        this.isPending = !0, this.timeoutId = setTimeout(() => {
+          this.lastArgs !== void 0 && this.execute(...this.lastArgs);
+        }, o);
+      }
+    }, this.execute = (...t) => {
+      this.fn(...t), this.options.onExecute?.(t, this), this.lastExecutionTime = Date.now(), this.clearTimeout(), this.lastArgs = void 0, this.isPending = !1;
+    }, this.flush = () => {
+      this.isPending && this.lastArgs && this.execute(...this.lastArgs);
+    }, this.cancel = () => {
+      this.clearTimeout(), this.lastArgs = void 0, this.isPending = !1;
+    }, this.clearTimeout = () => {
+      this.timeoutId && (clearTimeout(this.timeoutId), this.timeoutId = void 0);
+    }, this.options.leading === void 0 && this.options.trailing === void 0 && (this.options.leading = !0, this.options.trailing = !0);
+  }
+};
+function n(i, s) {
+  return new h(i, s).maybeExecute;
+}
+export {
+  h as LiteThrottler,
+  n as liteThrottle
+};

package/dist/es/node_modules/@tanstack/store/dist/esm/derived.js

@@ -0,0 +1,74 @@
+import { Store as p } from "./store.js";
+import { __storeToDerived as n, __derivedToStore as a } from "./scheduler.js";
+class r {
+  constructor(o) {
+    this.listeners = /* @__PURE__ */ new Set(), this._subscriptions = [], this.lastSeenDepValues = [], this.getDepVals = () => {
+      const e = this.options.deps.length, s = new Array(e), t = new Array(e);
+      for (let i = 0; i < e; i++) {
+        const l = this.options.deps[i];
+        s[i] = l.prevState, t[i] = l.state;
+      }
+      return this.lastSeenDepValues = t, {
+        prevDepVals: s,
+        currDepVals: t,
+        prevVal: this.prevState ?? void 0
+      };
+    }, this.recompute = () => {
+      var e, s;
+      this.prevState = this.state;
+      const t = this.getDepVals();
+      this.state = this.options.fn(t), (s = (e = this.options).onUpdate) == null || s.call(e);
+    }, this.checkIfRecalculationNeededDeeply = () => {
+      for (const i of this.options.deps)
+        i instanceof r && i.checkIfRecalculationNeededDeeply();
+      let e = !1;
+      const s = this.lastSeenDepValues, { currDepVals: t } = this.getDepVals();
+      for (let i = 0; i < t.length; i++)
+        if (t[i] !== s[i]) {
+          e = !0;
+          break;
+        }
+      e && this.recompute();
+    }, this.mount = () => (this.registerOnGraph(), this.checkIfRecalculationNeededDeeply(), () => {
+      this.unregisterFromGraph();
+      for (const e of this._subscriptions)
+        e();
+    }), this.subscribe = (e) => {
+      var s, t;
+      this.listeners.add(e);
+      const i = (t = (s = this.options).onSubscribe) == null ? void 0 : t.call(s, e, this);
+      return () => {
+        this.listeners.delete(e), i?.();
+      };
+    }, this.options = o, this.state = o.fn({
+      prevDepVals: void 0,
+      prevVal: void 0,
+      currDepVals: this.getDepVals().currDepVals
+    });
+  }
+  registerOnGraph(o = this.options.deps) {
+    for (const e of o)
+      if (e instanceof r)
+        e.registerOnGraph(), this.registerOnGraph(e.options.deps);
+      else if (e instanceof p) {
+        let s = n.get(e);
+        s || (s = /* @__PURE__ */ new Set(), n.set(e, s)), s.add(this);
+        let t = a.get(this);
+        t || (t = /* @__PURE__ */ new Set(), a.set(this, t)), t.add(e);
+      }
+  }
+  unregisterFromGraph(o = this.options.deps) {
+    for (const e of o)
+      if (e instanceof r)
+        this.unregisterFromGraph(e.options.deps);
+      else if (e instanceof p) {
+        const s = n.get(e);
+        s && s.delete(this);
+        const t = a.get(this);
+        t && t.delete(e);
+      }
+  }
+}
+export {
+  r as Derived
+};

package/dist/es/node_modules/@tanstack/store/dist/esm/scheduler.js

@@ -0,0 +1,79 @@
+import { Derived as p } from "./derived.js";
+const l = /* @__PURE__ */ new WeakMap(), _ = /* @__PURE__ */ new WeakMap(), c = {
+  current: []
+};
+let a = !1, o = 0;
+const s = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Map();
+function d(t) {
+  const r = Array.from(t).sort((e, n) => e instanceof p && e.options.deps.includes(n) ? 1 : n instanceof p && n.options.deps.includes(e) ? -1 : 0);
+  for (const e of r) {
+    if (c.current.includes(e))
+      continue;
+    c.current.push(e), e.recompute();
+    const n = _.get(e);
+    if (n)
+      for (const f of n) {
+        const u = l.get(f);
+        u && d(u);
+      }
+  }
+}
+function v(t) {
+  const r = {
+    prevVal: t.prevState,
+    currentVal: t.state
+  };
+  for (const e of t.listeners)
+    e(r);
+}
+function h(t) {
+  const r = {
+    prevVal: t.prevState,
+    currentVal: t.state
+  };
+  for (const e of t.listeners)
+    e(r);
+}
+function g(t) {
+  if (o > 0 && !i.has(t) && i.set(t, t.prevState), s.add(t), !(o > 0) && !a)
+    try {
+      for (a = !0; s.size > 0; ) {
+        const r = Array.from(s);
+        s.clear();
+        for (const e of r) {
+          const n = i.get(e) ?? e.prevState;
+          e.prevState = n, v(e);
+        }
+        for (const e of r) {
+          const n = l.get(e);
+          n && (c.current.push(e), d(n));
+        }
+        for (const e of r) {
+          const n = l.get(e);
+          if (n)
+            for (const f of n)
+              h(f);
+        }
+      }
+    } finally {
+      a = !1, c.current = [], i.clear();
+    }
+}
+function S(t) {
+  o++;
+  try {
+    t();
+  } finally {
+    if (o--, o === 0) {
+      const r = s.values().next().value;
+      r && g(r);
+    }
+  }
+}
+export {
+  c as __depsThatHaveWrittenThisTick,
+  _ as __derivedToStore,
+  g as __flush,
+  l as __storeToDerived,
+  S as batch
+};

package/dist/es/node_modules/@tanstack/store/dist/esm/store.js

@@ -0,0 +1,21 @@
+import { __flush as h } from "./scheduler.js";
+import { isUpdaterFunction as l } from "./types.js";
+class u {
+  constructor(t, e) {
+    this.listeners = /* @__PURE__ */ new Set(), this.subscribe = (s) => {
+      var i, o;
+      this.listeners.add(s);
+      const n = (o = (i = this.options) == null ? void 0 : i.onSubscribe) == null ? void 0 : o.call(i, s, this);
+      return () => {
+        this.listeners.delete(s), n?.();
+      };
+    }, this.prevState = t, this.state = t, this.options = e;
+  }
+  setState(t) {
+    var e, s, i;
+    this.prevState = this.state, (e = this.options) != null && e.updateFn ? this.state = this.options.updateFn(this.prevState)(t) : l(t) ? this.state = t(this.prevState) : this.state = t, (i = (s = this.options) == null ? void 0 : s.onUpdate) == null || i.call(s), h(this);
+  }
+}
+export {
+  u as Store
+};

package/dist/es/node_modules/@tanstack/store/dist/esm/types.js

@@ -0,0 +1,6 @@
+function t(n) {
+  return typeof n == "function";
+}
+export {
+  t as isUpdaterFunction
+};