@gsc-basic/components 1.0.1 → 1.0.3

package/dist/es/node_modules/@lezer/lr/dist/index.js

@@ -112,11 +112,13 @@ class v {
       this.pushState(t & 65535, this.pos);
     else if ((t & 262144) == 0) {
       let h = t, { parser: r } = this.p;
-      (i > this.pos || e <= r.maxNode) && (this.pos = i, r.stateFlag(
+      this.pos = i;
+      let n = r.stateFlag(
         h,
         1
         /* StateFlag.Skipped */
-      ) || (this.reducePos = i)), this.pushState(h, s), this.shiftContext(e, s), e <= r.maxNode && this.buffer.push(e, s, i, 4);
+      );
+      !n && (i > s || e <= r.maxNode) && (this.reducePos = i), this.pushState(h, n ? s : Math.min(s, this.reducePos)), this.shiftContext(e, s), e <= r.maxNode && this.buffer.push(e, s, i, 4);
     } else
       this.pos = i, this.shiftContext(e, s), e <= this.p.parser.maxNode && this.buffer.push(e, s, i, 4);
   }
@@ -978,7 +980,7 @@ class K {
         g && (p = this.stackID(f) + " -> ");
       for (let c of n.recoverByInsert(o))
         g && console.log(u + this.stackID(c) + " (via recover-insert)"), this.advanceFully(c, s);
-      this.stream.end > n.pos ? (a == n.pos && (a++, o = 0), n.recoverByDelete(o, a), g && console.log(u + this.stackID(n) + ` (via recover-delete ${this.parser.getName(o)})`), D(n, s)) : (!i || i.score < n.score) && (i = n);
+      this.stream.end > n.pos ? (a == n.pos && (a++, o = 0), n.recoverByDelete(o, a), g && console.log(u + this.stackID(n) + ` (via recover-delete ${this.parser.getName(o)})`), D(n, s)) : (!i || i.score < f.score) && (i = f);
     }
     return i;
   }

package/dist/es/node_modules/@tanstack/devtools-event-client/dist/esm/plugin.js

@@ -0,0 +1,178 @@
+class a {
+  #o = !0;
+  #e;
+  #t;
+  #u;
+  #n;
+  #r;
+  #i;
+  #a;
+  #l = 0;
+  #v = 5;
+  #h = !1;
+  #d = !1;
+  #s = null;
+  #c = () => {
+    this.debugLog("Connected to event bus"), this.#r = !0, this.#h = !1, this.debugLog("Emitting queued events", this.#n), this.#n.forEach((t) => this.emitEventToBus(t)), this.#n = [], this.stopConnectLoop(), this.#t().removeEventListener(
+      "tanstack-connect-success",
+      this.#c
+    );
+  };
+  // fired off right away and then at intervals
+  #g = () => {
+    if (this.#l < this.#v) {
+      this.#l++, this.dispatchCustomEvent("tanstack-connect", {});
+      return;
+    }
+    this.#t().removeEventListener(
+      "tanstack-connect",
+      this.#g
+    ), this.#d = !0, this.debugLog("Max retries reached, giving up on connection"), this.stopConnectLoop();
+  };
+  // This is run to register connection handlers on first emit attempt
+  #E = () => {
+    this.#h || (this.#h = !0, this.#t().addEventListener(
+      "tanstack-connect-success",
+      this.#c
+    ), this.#g());
+  };
+  constructor({
+    pluginId: t,
+    debug: e = !1,
+    enabled: n = !0,
+    reconnectEveryMs: i = 300
+  }) {
+    this.#e = t, this.#o = n, this.#t = this.getGlobalTarget, this.#u = e, this.debugLog(" Initializing event subscription for plugin", this.#e), this.#n = [], this.#r = !1, this.#d = !1, this.#i = null, this.#a = i;
+  }
+  startConnectLoop() {
+    this.#i !== null || this.#r || (this.debugLog(`Starting connect loop (every ${this.#a}ms)`), this.#i = setInterval(
+      this.#g,
+      this.#a
+    ));
+  }
+  stopConnectLoop() {
+    this.#h = !1, this.#i !== null && (clearInterval(this.#i), this.#i = null, this.#n = [], this.debugLog("Stopped connect loop"));
+  }
+  debugLog(...t) {
+    this.#u && console.log(`🌴 [tanstack-devtools:${this.#e}-plugin]`, ...t);
+  }
+  getGlobalTarget() {
+    if (typeof globalThis < "u" && globalThis.__TANSTACK_EVENT_TARGET__)
+      return this.debugLog("Using global event target"), globalThis.__TANSTACK_EVENT_TARGET__;
+    if (typeof window < "u" && typeof window.addEventListener < "u")
+      return this.debugLog("Using window as event target"), window;
+    const t = typeof EventTarget < "u" ? new EventTarget() : void 0;
+    return typeof t > "u" || typeof t.addEventListener > "u" ? (this.debugLog(
+      "No event mechanism available, running in non-web environment"
+    ), {
+      addEventListener: () => {
+      },
+      removeEventListener: () => {
+      },
+      dispatchEvent: () => !1
+    }) : (this.debugLog("Using new EventTarget as fallback"), t);
+  }
+  getPluginId() {
+    return this.#e;
+  }
+  dispatchCustomEventShim(t, e) {
+    try {
+      const n = new Event(t, {
+        detail: e
+      });
+      this.#t().dispatchEvent(n);
+    } catch {
+      this.debugLog("Failed to dispatch shim event");
+    }
+  }
+  dispatchCustomEvent(t, e) {
+    try {
+      this.#t().dispatchEvent(new CustomEvent(t, { detail: e }));
+    } catch {
+      this.dispatchCustomEventShim(t, e);
+    }
+  }
+  emitEventToBus(t) {
+    this.debugLog("Emitting event to client bus", t), this.dispatchCustomEvent("tanstack-dispatch-event", t);
+  }
+  createEventPayload(t, e) {
+    return {
+      type: `${this.#e}:${t}`,
+      payload: e,
+      pluginId: this.#e
+    };
+  }
+  emit(t, e) {
+    if (!this.#o) {
+      this.debugLog(
+        "Event bus client is disabled, not emitting event",
+        t,
+        e
+      );
+      return;
+    }
+    if (this.#s && (this.debugLog(
+      "Emitting event to internal event target",
+      t,
+      e
+    ), this.#s.dispatchEvent(
+      new CustomEvent(`${this.#e}:${t}`, {
+        detail: this.createEventPayload(t, e)
+      })
+    )), this.#d) {
+      this.debugLog("Previously failed to connect, not emitting to bus");
+      return;
+    }
+    if (!this.#r) {
+      this.debugLog("Bus not available, will be pushed as soon as connected"), this.#n.push(this.createEventPayload(t, e)), typeof CustomEvent < "u" && !this.#h && (this.#E(), this.startConnectLoop());
+      return;
+    }
+    return this.emitEventToBus(this.createEventPayload(t, e));
+  }
+  on(t, e, n) {
+    const i = n?.withEventTarget ?? !1, s = `${this.#e}:${t}`;
+    if (i && (this.#s || (this.#s = new EventTarget()), this.#s.addEventListener(s, (o) => {
+      e(o.detail);
+    })), !this.#o)
+      return this.debugLog(
+        "Event bus client is disabled, not registering event",
+        s
+      ), () => {
+      };
+    const h = (o) => {
+      this.debugLog("Received event from bus", o.detail), e(o.detail);
+    };
+    return this.#t().addEventListener(s, h), this.debugLog("Registered event to bus", s), () => {
+      i && this.#s?.removeEventListener(s, h), this.#t().removeEventListener(s, h);
+    };
+  }
+  onAll(t) {
+    if (!this.#o)
+      return this.debugLog("Event bus client is disabled, not registering event"), () => {
+      };
+    const e = (n) => {
+      const i = n.detail;
+      t(i);
+    };
+    return this.#t().addEventListener("tanstack-devtools-global", e), () => this.#t().removeEventListener(
+      "tanstack-devtools-global",
+      e
+    );
+  }
+  onAllPluginEvents(t) {
+    if (!this.#o)
+      return this.debugLog("Event bus client is disabled, not registering event"), () => {
+      };
+    const e = (n) => {
+      const i = n.detail;
+      this.#e && i.pluginId !== this.#e || t(i);
+    };
+    return this.#t().addEventListener("tanstack-devtools-global", e), () => this.#t().removeEventListener(
+      "tanstack-devtools-global",
+      e
+    );
+  }
+}
+export {
+  a as EventClient
+};

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

@@ -0,0 +1,13 @@
+import { EventClient as e } from "../../../devtools-event-client/dist/esm/plugin.js";
+class t extends e {
+  constructor() {
+    super({
+      pluginId: "form-devtools",
+      reconnectEveryMs: 1e3
+    });
+  }
+}
+const r = new t();
+export {
+  r as formEventClient
+};

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

@@ -0,0 +1,406 @@
+import { Derived as K } from "../../../store/dist/esm/derived.js";
+import { batch as U } from "../../../store/dist/esm/scheduler.js";
+import { standardSchemaValidators as b, isStandardSchemaValidator as W } from "./standardSchemaValidator.js";
+import { defaultFieldMeta as x } from "./metaHelper.js";
+import { evaluate as C, mergeOpts as g, getSyncValidatorArray as T, determineFieldLevelErrorSourceAndValue as R, getAsyncValidatorArray as E } from "./utils.js";
+import { defaultValidationLogic as F } from "./ValidationLogic.js";
+class Q {
+  /**
+   * Initializes a new `FieldApi` instance.
+   */
+  constructor(n) {
+    this.options = {}, this.mount = () => {
+      const t = this.store.mount();
+      this.options.defaultValue !== void 0 && !this.getMeta().isTouched && this.form.setFieldValue(this.name, this.options.defaultValue, {
+        dontUpdateMeta: !0
+      });
+      const e = this.getInfo();
+      e.instance = this, this.update(this.options);
+      const { onMount: i } = this.options.validators || {};
+      if (i) {
+        const a = this.runValidator({
+          validate: i,
+          value: {
+            value: this.state.value,
+            fieldApi: this,
+            validationSource: "field"
+          },
+          type: "validate"
+        });
+        a && this.setMeta(
+          (l) => ({
+            ...l,
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            errorMap: { ...l?.errorMap, onMount: a },
+            errorSourceMap: {
+              // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+              ...l?.errorSourceMap,
+              onMount: "field"
+            }
+          })
+        );
+      }
+      return this.options.listeners?.onMount?.({
+        value: this.state.value,
+        fieldApi: this
+      }), t;
+    }, this.update = (t) => {
+      if (this.options = t, this.name = t.name, !this.state.meta.isTouched && this.options.defaultValue !== void 0) {
+        const e = this.form.getFieldValue(this.name);
+        C(e, t.defaultValue) || this.form.setFieldValue(this.name, t.defaultValue, {
+          dontUpdateMeta: !0,
+          dontValidate: !0,
+          dontRunListeners: !0
+        });
+      }
+      this.form.getFieldMeta(this.name) || this.form.setFieldMeta(this.name, this.state.meta);
+    }, this.getValue = () => this.form.getFieldValue(this.name), this.setValue = (t, e) => {
+      this.form.setFieldValue(
+        this.name,
+        t,
+        g(e, { dontRunListeners: !0, dontValidate: !0 })
+      ), e?.dontRunListeners || this.triggerOnChangeListener(), e?.dontValidate || this.validate("change");
+    }, this.getMeta = () => this.store.state.meta, this.setMeta = (t) => this.form.setFieldMeta(this.name, t), this.getInfo = () => this.form.getFieldInfo(this.name), this.pushValue = (t, e) => {
+      this.form.pushFieldValue(
+        this.name,
+        t,
+        g(e, { dontRunListeners: !0 })
+      ), e?.dontRunListeners || this.triggerOnChangeListener();
+    }, this.insertValue = (t, e, i) => {
+      this.form.insertFieldValue(
+        this.name,
+        t,
+        e,
+        g(i, { dontRunListeners: !0 })
+      ), i?.dontRunListeners || this.triggerOnChangeListener();
+    }, this.replaceValue = (t, e, i) => {
+      this.form.replaceFieldValue(
+        this.name,
+        t,
+        e,
+        g(i, { dontRunListeners: !0 })
+      ), i?.dontRunListeners || this.triggerOnChangeListener();
+    }, this.removeValue = (t, e) => {
+      this.form.removeFieldValue(
+        this.name,
+        t,
+        g(e, { dontRunListeners: !0 })
+      ), e?.dontRunListeners || this.triggerOnChangeListener();
+    }, this.swapValues = (t, e, i) => {
+      this.form.swapFieldValues(
+        this.name,
+        t,
+        e,
+        g(i, { dontRunListeners: !0 })
+      ), i?.dontRunListeners || this.triggerOnChangeListener();
+    }, this.moveValue = (t, e, i) => {
+      this.form.moveFieldValues(
+        this.name,
+        t,
+        e,
+        g(i, { dontRunListeners: !0 })
+      ), i?.dontRunListeners || this.triggerOnChangeListener();
+    }, this.clearValues = (t) => {
+      this.form.clearFieldValues(
+        this.name,
+        g(t, { dontRunListeners: !0 })
+      ), t?.dontRunListeners || this.triggerOnChangeListener();
+    }, this.getLinkedFields = (t) => {
+      const e = Object.values(this.form.fieldInfo), i = [];
+      for (const a of e) {
+        if (!a.instance) continue;
+        const { onChangeListenTo: l, onBlurListenTo: m } = a.instance.options.validators || {};
+        t === "change" && l?.includes(this.name) && i.push(a.instance), t === "blur" && m?.includes(this.name) && i.push(a.instance);
+      }
+      return i;
+    }, this.validateSync = (t, e) => {
+      const i = T(t, {
+        ...this.options,
+        form: this.form,
+        validationLogic: this.form.options.validationLogic || F
+      }), l = this.getLinkedFields(t).reduce(
+        (u, r) => {
+          const h = T(t, {
+            ...r.options,
+            form: r.form,
+            validationLogic: r.form.options.validationLogic || F
+          });
+          return h.forEach((d) => {
+            d.field = r;
+          }), u.concat(h);
+        },
+        []
+      );
+      let m = !1;
+      U(() => {
+        const u = (r, h) => {
+          const d = A(h.cause), s = h.validate ? w(
+            r.runValidator({
+              validate: h.validate,
+              value: {
+                value: r.store.state.value,
+                validationSource: "field",
+                fieldApi: r
+              },
+              type: "validate"
+            })
+          ) : void 0, o = e[d], { newErrorValue: c, newSource: f } = R({
+            formLevelError: o,
+            fieldLevelError: s
+          });
+          r.state.meta.errorMap?.[d] !== c && r.setMeta((V) => ({
+            ...V,
+            errorMap: {
+              ...V.errorMap,
+              [d]: c
+            },
+            errorSourceMap: {
+              ...V.errorSourceMap,
+              [d]: f
+            }
+          })), c && (m = !0);
+        };
+        for (const r of i)
+          u(this, r);
+        for (const r of l)
+          r.validate && u(r.field, r);
+      });
+      const p = A("submit");
+      return (
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        this.state.meta.errorMap?.[p] && t !== "submit" && !m && this.setMeta((u) => ({
+          ...u,
+          errorMap: {
+            ...u.errorMap,
+            [p]: void 0
+          },
+          errorSourceMap: {
+            ...u.errorSourceMap,
+            [p]: void 0
+          }
+        })), { hasErrored: m }
+      );
+    }, this.validateAsync = async (t, e) => {
+      const i = E(t, {
+        ...this.options,
+        form: this.form,
+        validationLogic: this.form.options.validationLogic || F
+      }), a = await e, l = this.getLinkedFields(t), m = l.reduce(
+        (s, o) => {
+          const c = E(t, {
+            ...o.options,
+            form: o.form,
+            validationLogic: o.form.options.validationLogic || F
+          });
+          return c.forEach((f) => {
+            f.field = o;
+          }), s.concat(c);
+        },
+        []
+      ), p = [], u = [], r = i.some((s) => s.validate) || m.some((s) => s.validate);
+      if (r) {
+        this.state.meta.isValidating || this.setMeta((s) => ({ ...s, isValidating: !0 }));
+        for (const s of l)
+          s.setMeta((o) => ({ ...o, isValidating: !0 }));
+      }
+      const h = (s, o, c) => {
+        const f = A(o.cause);
+        s.getInfo().validationMetaMap[f]?.lastAbortController.abort();
+        const L = new AbortController();
+        this.getInfo().validationMetaMap[f] = {
+          lastAbortController: L
+        }, c.push(
+          new Promise(async (S) => {
+            let y;
+            try {
+              y = await new Promise((v, O) => {
+                this.timeoutIds.validations[o.cause] && clearTimeout(this.timeoutIds.validations[o.cause]), this.timeoutIds.validations[o.cause] = setTimeout(
+                  async () => {
+                    if (L.signal.aborted) return v(void 0);
+                    try {
+                      v(
+                        await this.runValidator({
+                          validate: o.validate,
+                          value: {
+                            value: s.store.state.value,
+                            fieldApi: s,
+                            signal: L.signal,
+                            validationSource: "field"
+                          },
+                          type: "validateAsync"
+                        })
+                      );
+                    } catch (P) {
+                      O(P);
+                    }
+                  },
+                  o.debounceMs
+                );
+              });
+            } catch (v) {
+              y = v;
+            }
+            if (L.signal.aborted) return S(void 0);
+            const k = w(y), B = a[this.name]?.[f], { newErrorValue: I, newSource: D } = R({
+              formLevelError: B,
+              fieldLevelError: k
+            });
+            s.setMeta((v) => ({
+              ...v,
+              errorMap: {
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                ...v?.errorMap,
+                [f]: I
+              },
+              errorSourceMap: {
+                ...v.errorSourceMap,
+                [f]: D
+              }
+            })), S(I);
+          })
+        );
+      };
+      for (const s of i)
+        s.validate && h(this, s, p);
+      for (const s of m)
+        s.validate && h(
+          s.field,
+          s,
+          u
+        );
+      let d = [];
+      if ((p.length || u.length) && (d = await Promise.all(p), await Promise.all(u)), r) {
+        this.setMeta((s) => ({ ...s, isValidating: !1 }));
+        for (const s of l)
+          s.setMeta((o) => ({ ...o, isValidating: !1 }));
+      }
+      return d.filter(Boolean);
+    }, this.validate = (t, e) => {
+      if (!this.state.meta.isTouched) return [];
+      const { fieldsErrorMap: i } = e?.skipFormValidation ? { fieldsErrorMap: {} } : this.form.validateSync(t), { hasErrored: a } = this.validateSync(
+        t,
+        i[this.name] ?? {}
+      );
+      if (a && !this.options.asyncAlways)
+        return this.getInfo().validationMetaMap[A(t)]?.lastAbortController.abort(), this.state.meta.errors;
+      const l = e?.skipFormValidation ? Promise.resolve({}) : this.form.validateAsync(t);
+      return this.validateAsync(t, l);
+    }, this.handleChange = (t) => {
+      this.setValue(t);
+    }, this.handleBlur = () => {
+      this.state.meta.isTouched || this.setMeta((e) => ({ ...e, isTouched: !0 })), this.state.meta.isBlurred || this.setMeta((e) => ({ ...e, isBlurred: !0 })), this.validate("blur"), this.triggerOnBlurListener();
+    }, this.setErrorMap = (t) => {
+      this.setMeta((e) => ({
+        ...e,
+        errorMap: {
+          ...e.errorMap,
+          ...t
+        }
+      }));
+    }, this.parseValueWithSchema = (t) => b.validate(
+      { value: this.state.value, validationSource: "field" },
+      t
+    ), this.parseValueWithSchemaAsync = (t) => b.validateAsync(
+      { value: this.state.value, validationSource: "field" },
+      t
+    ), this.triggerOnChangeListener = () => {
+      const t = this.form.options.listeners?.onChangeDebounceMs;
+      t && t > 0 ? (this.timeoutIds.formListeners.change && clearTimeout(this.timeoutIds.formListeners.change), this.timeoutIds.formListeners.change = setTimeout(() => {
+        this.form.options.listeners?.onChange?.({
+          formApi: this.form,
+          fieldApi: this
+        });
+      }, t)) : this.form.options.listeners?.onChange?.({
+        formApi: this.form,
+        fieldApi: this
+      });
+      const e = this.options.listeners?.onChangeDebounceMs;
+      e && e > 0 ? (this.timeoutIds.listeners.change && clearTimeout(this.timeoutIds.listeners.change), this.timeoutIds.listeners.change = setTimeout(() => {
+        this.options.listeners?.onChange?.({
+          value: this.state.value,
+          fieldApi: this
+        });
+      }, e)) : this.options.listeners?.onChange?.({
+        value: this.state.value,
+        fieldApi: this
+      });
+    }, this.form = n.form, this.name = n.name, this.options = n, this.timeoutIds = {
+      validations: {},
+      listeners: {},
+      formListeners: {}
+    }, this.store = new K({
+      deps: [this.form.store],
+      fn: ({ prevVal: t }) => {
+        const e = t, i = this.form.getFieldMeta(this.name) ?? {
+          ...x,
+          ...n.defaultMeta
+        };
+        let a = this.form.getFieldValue(this.name);
+        return !i.isTouched && a === void 0 && this.options.defaultValue !== void 0 && !C(a, this.options.defaultValue) && (a = this.options.defaultValue), e && e.value === a && e.meta === i ? e : {
+          value: a,
+          meta: i
+        };
+      }
+    });
+  }
+  /**
+   * The current field state.
+   */
+  get state() {
+    return this.store.state;
+  }
+  /**
+   * @private
+   */
+  runValidator(n) {
+    return W(n.validate) ? b[n.type](
+      n.value,
+      n.validate
+    ) : n.validate(n.value);
+  }
+  triggerOnBlurListener() {
+    const n = this.form.options.listeners?.onBlurDebounceMs;
+    n && n > 0 ? (this.timeoutIds.formListeners.blur && clearTimeout(this.timeoutIds.formListeners.blur), this.timeoutIds.formListeners.blur = setTimeout(() => {
+      this.form.options.listeners?.onBlur?.({
+        formApi: this.form,
+        fieldApi: this
+      });
+    }, n)) : this.form.options.listeners?.onBlur?.({
+      formApi: this.form,
+      fieldApi: this
+    });
+    const t = this.options.listeners?.onBlurDebounceMs;
+    t && t > 0 ? (this.timeoutIds.listeners.blur && clearTimeout(this.timeoutIds.listeners.blur), this.timeoutIds.listeners.blur = setTimeout(() => {
+      this.options.listeners?.onBlur?.({
+        value: this.state.value,
+        fieldApi: this
+      });
+    }, t)) : this.options.listeners?.onBlur?.({
+      value: this.state.value,
+      fieldApi: this
+    });
+  }
+}
+function w(M) {
+  if (M)
+    return M;
+}
+function A(M) {
+  switch (M) {
+    case "submit":
+      return "onSubmit";
+    case "blur":
+      return "onBlur";
+    case "mount":
+      return "onMount";
+    case "server":
+      return "onServer";
+    case "dynamic":
+      return "onDynamic";
+    default:
+      return "onChange";
+  }
+}
+export {
+  Q as FieldApi
+};