npm - solid-hook-form - Versions diffs - 1.0.0 - Mend

solid-hook-form 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/README.md ADDED Viewed

@@ -0,0 +1,13 @@
+# solid-hook-form
+```tsx
+import { useForm } from "solid-hook-form";
+const { errors, isValid, register } = useForm({
+  defaultValues: {
+    email: "",
+  },
+});
+register("email", { required: true });
+```

package/dist/main.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export { useForm } from './use_form';

package/dist/main.js ADDED Viewed

@@ -0,0 +1,213 @@
+const _ = (t, s) => t === s, q = {
+  equals: _
+};
+let G = j;
+const g = 1, w = 2;
+var b = null;
+let V = null, P = null, i = null, o = null, h = null, A = 0;
+function x(t, s) {
+  s = s ? Object.assign({}, q, s) : q;
+  const e = {
+    value: t,
+    observers: null,
+    observerSlots: null,
+    comparator: s.equals || void 0
+  }, r = (u) => (typeof u == "function" && (u = u(e.value)), D(e, u));
+  return [z.bind(e), r];
+}
+function Q(t) {
+  if (i === null) return t();
+  const s = i;
+  i = null;
+  try {
+    return t();
+  } finally {
+    i = s;
+  }
+}
+function z() {
+  if (this.sources && this.state)
+    if (this.state === g) F(this);
+    else {
+      const t = o;
+      o = null, O(() => S(this)), o = t;
+    }
+  if (i) {
+    const t = this.observers ? this.observers.length : 0;
+    i.sources ? (i.sources.push(this), i.sourceSlots.push(t)) : (i.sources = [this], i.sourceSlots = [t]), this.observers ? (this.observers.push(i), this.observerSlots.push(i.sources.length - 1)) : (this.observers = [i], this.observerSlots = [i.sources.length - 1]);
+  }
+  return this.value;
+}
+function D(t, s, e) {
+  let r = t.value;
+  return (!t.comparator || !t.comparator(r, s)) && (t.value = s, t.observers && t.observers.length && O(() => {
+    for (let u = 0; u < t.observers.length; u += 1) {
+      const l = t.observers[u], f = V && V.running;
+      f && V.disposed.has(l), (f ? !l.tState : !l.state) && (l.pure ? o.push(l) : h.push(l), l.observers && T(l)), f || (l.state = g);
+    }
+    if (o.length > 1e6)
+      throw o = [], new Error();
+  })), s;
+}
+function F(t) {
+  if (!t.fn) return;
+  E(t);
+  const s = A;
+  B(
+    t,
+    t.value,
+    s
+  );
+}
+function B(t, s, e) {
+  let r;
+  const u = b, l = i;
+  i = b = t;
+  try {
+    r = t.fn(s);
+  } catch (f) {
+    return t.pure && (t.state = g, t.owned && t.owned.forEach(E), t.owned = null), t.updatedAt = e + 1, N(f);
+  } finally {
+    i = l, b = u;
+  }
+  (!t.updatedAt || t.updatedAt <= e) && (t.updatedAt != null && "observers" in t ? D(t, r) : t.value = r, t.updatedAt = e);
+}
+function U(t) {
+  if (t.state === 0) return;
+  if (t.state === w) return S(t);
+  if (t.suspense && Q(t.suspense.inFallback)) return t.suspense.effects.push(t);
+  const s = [t];
+  for (; (t = t.owner) && (!t.updatedAt || t.updatedAt < A); )
+    t.state && s.push(t);
+  for (let e = s.length - 1; e >= 0; e--)
+    if (t = s[e], t.state === g)
+      F(t);
+    else if (t.state === w) {
+      const r = o;
+      o = null, O(() => S(t, s[0])), o = r;
+    }
+}
+function O(t, s) {
+  if (o) return t();
+  let e = !1;
+  o = [], h ? e = !0 : h = [], A++;
+  try {
+    const r = t();
+    return H(e), r;
+  } catch (r) {
+    e || (h = null), o = null, N(r);
+  }
+}
+function H(t) {
+  if (o && (j(o), o = null), t) return;
+  const s = h;
+  h = null, s.length && O(() => G(s));
+}
+function j(t) {
+  for (let s = 0; s < t.length; s++) U(t[s]);
+}
+function S(t, s) {
+  t.state = 0;
+  for (let e = 0; e < t.sources.length; e += 1) {
+    const r = t.sources[e];
+    if (r.sources) {
+      const u = r.state;
+      u === g ? r !== s && (!r.updatedAt || r.updatedAt < A) && U(r) : u === w && S(r, s);
+    }
+  }
+}
+function T(t) {
+  for (let s = 0; s < t.observers.length; s += 1) {
+    const e = t.observers[s];
+    e.state || (e.state = w, e.pure ? o.push(e) : h.push(e), e.observers && T(e));
+  }
+}
+function E(t) {
+  let s;
+  if (t.sources)
+    for (; t.sources.length; ) {
+      const e = t.sources.pop(), r = t.sourceSlots.pop(), u = e.observers;
+      if (u && u.length) {
+        const l = u.pop(), f = e.observerSlots.pop();
+        r < u.length && (l.sourceSlots[f] = r, u[r] = l, e.observerSlots[r] = f);
+      }
+    }
+  if (t.tOwned) {
+    for (s = t.tOwned.length - 1; s >= 0; s--) E(t.tOwned[s]);
+    delete t.tOwned;
+  }
+  if (t.owned) {
+    for (s = t.owned.length - 1; s >= 0; s--) E(t.owned[s]);
+    t.owned = null;
+  }
+  if (t.cleanups) {
+    for (s = t.cleanups.length - 1; s >= 0; s--) t.cleanups[s]();
+    t.cleanups = null;
+  }
+  t.state = 0;
+}
+function J(t) {
+  return t instanceof Error ? t : new Error(typeof t == "string" ? t : "Unknown error", {
+    cause: t
+  });
+}
+function N(t, s = b) {
+  throw J(t);
+}
+const X = ({
+  defaultValues: t,
+  mode: s = "onInput"
+}) => {
+  const e = t, r = {}, u = {}, [l, f] = x({}), [k, C] = x(!0), y = (n) => {
+    const a = r[n], c = u[n];
+    c != null && c.required && !(a != null && a.value) ? f((p) => {
+      const v = { message: "Required" };
+      return { ...p, [n]: v };
+    }) : f((p) => {
+      const v = { ...p };
+      return delete v[n], v;
+    }), C(!Object.keys(l()).length);
+  }, L = () => {
+    Object.keys(e).forEach((n) => {
+      y(n);
+    });
+  }, R = (n, a) => (a && (u[n] = { required: a.required }), {
+    name: n,
+    value: e[n],
+    onInput(c) {
+      if (s === "onInput") {
+        const p = c.target.value;
+        e[n] = p, y(n);
+      }
+    },
+    onChange(c) {
+      if (s === "onChange") {
+        const p = c.target.value;
+        e[n] = p, y(n);
+      }
+    },
+    ref: (c) => {
+      r[n] || (r[n] = c, c && (c.value = e[n]));
+    }
+  }), I = (n) => n ? e[n] : e;
+  return {
+    errors: l,
+    isValid: k,
+    register: R,
+    getValues: I,
+    setValue: (n, a) => {
+      e[n] = a;
+      const c = r[n];
+      c && (c.value = a);
+    },
+    onSubmit: (n) => (a) => {
+      a.preventDefault(), L(), k() && n(I());
+    },
+    reset: (n) => {
+      Object.assign(e, n || t), f({}), C(!0);
+    }
+  };
+};
+export {
+  X as useForm
+};

package/dist/main.umd.cjs ADDED Viewed

@@ -0,0 +1 @@

package/dist/types/array.d.ts ADDED Viewed

@@ -0,0 +1,23 @@
+/**
+ * Type which can be used to index an array or tuple type.
+ */
+export type ArrayKey = number;
+/**
+ * Type which given a tuple type returns its own keys, i.e. only its indices.
+ * @typeParam T - tuple type
+ * @example
+ * ```
+ * TupleKeys<[number, string]> = '0' | '1'
+ * ```
+ */
+export type TupleKeys<T extends ReadonlyArray<any>> = Exclude<keyof T, keyof any[]>;
+/**
+ * Type to query whether an array type T is a tuple type.
+ * @typeParam T - type which may be an array or tuple
+ * @example
+ * ```
+ * IsTuple<[number]> = true
+ * IsTuple<number[]> = false
+ * ```
+ */
+export type IsTuple<T extends ReadonlyArray<any>> = number extends T["length"] ? false : true;

package/dist/types/errors.d.ts ADDED Viewed

@@ -0,0 +1,19 @@
+import { FormValues } from './form';
+import { BrowserNativeObject, IsAny, Merge } from './utils';
+export type FieldError = {
+    message?: Message;
+};
+export type Message = string;
+export type GlobalError = Partial<{
+    type: string | number;
+    message: Message;
+}>;
+export type DeepRequired<T> = T extends BrowserNativeObject | Blob ? T : {
+    [K in keyof T]-?: NonNullable<DeepRequired<T[K]>>;
+};
+export type FieldErrorsImpl<T extends FormValues = FormValues> = {
+    [K in keyof T]?: T[K] extends BrowserNativeObject | Blob ? FieldError : K extends "root" | `root.${string}` ? GlobalError : T[K] extends object ? Merge<FieldError, FieldErrorsImpl<T[K]>> : FieldError;
+};
+export type FieldErrors<T extends FormValues = FormValues> = Partial<FormValues extends IsAny<FormValues> ? any : FieldErrorsImpl<DeepRequired<T>>> & {
+    root?: Record<string, GlobalError> & GlobalError;
+};

package/dist/types/form.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export type FormValues = Record<string, any>;

package/dist/types/path.d.ts ADDED Viewed

@@ -0,0 +1,23 @@
+import { ArrayKey, IsTuple, TupleKeys } from './array';
+import { BrowserNativeObject, IsEqual, Primitive } from './utils';
+/**
+ * Helper function to break apart T1 and check if any are equal to T2
+ *
+ * See {@link IsEqual}
+ */
+type AnyIsEqual<T1, T2> = T1 extends T2 ? (IsEqual<T1, T2> extends true ? true : never) : never;
+/**
+ * Helper type for recursively constructing paths through a type.
+ * This actually constructs the strings and recurses into nested
+ * object types.
+ *
+ * See {@link Path}
+ */
+type PathImpl<K extends string | number, V, TraversedTypes> = V extends Primitive | BrowserNativeObject ? `${K}` : true extends AnyIsEqual<TraversedTypes, V> ? `${K}` : `${K}` | `${K}.${PathInternal<V, TraversedTypes | V>}`;
+type PathInternal<T, TraversedTypes = T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
+    [K in TupleKeys<T>]-?: PathImpl<K & string, T[K], TraversedTypes>;
+}[TupleKeys<T>] : PathImpl<ArrayKey, V, TraversedTypes> : {
+    [K in keyof T]-?: PathImpl<K & string, T[K], TraversedTypes>;
+}[keyof T];
+export type Path<T> = T extends any ? PathInternal<T> : never;
+export {};

package/dist/types/utils.d.ts ADDED Viewed

@@ -0,0 +1,30 @@
+export type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+export type BrowserNativeObject = Date | FileList | File;
+/**
+ * Checks whether T1 can be exactly (mutually) assigned to T2
+ * @typeParam T1 - type to check
+ * @typeParam T2 - type to check against
+ * ```
+ * IsEqual<string, string> = true
+ * IsEqual<'foo', 'foo'> = true
+ * IsEqual<string, number> = false
+ * IsEqual<string, number> = false
+ * IsEqual<string, 'foo'> = false
+ * IsEqual<'foo', string> = false
+ * IsEqual<'foo' | 'bar', 'foo'> = boolean // 'foo' is assignable, but 'bar' is not (true | false) -> boolean
+ * ```
+ */
+export type IsEqual<T1, T2> = T1 extends T2 ? (<G>() => G extends T1 ? 1 : 2) extends <G>() => G extends T2 ? 1 : 2 ? true : false : false;
+/**
+ * Checks whether the type is any
+ * See {@link https://stackoverflow.com/a/49928360/3406963}
+ * @typeParam T - type which may be any
+ * ```
+ * IsAny<any> = true
+ * IsAny<string> = false
+ * ```
+ */
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+export type Merge<A, B> = {
+    [K in keyof A | keyof B]?: K extends keyof A & keyof B ? [A[K], B[K]] extends [object, object] ? Merge<A[K], B[K]> : A[K] | B[K] : K extends keyof A ? A[K] : K extends keyof B ? B[K] : never;
+};

package/dist/use_form.d.ts ADDED Viewed

@@ -0,0 +1,27 @@
+import { FormValues } from './types/form';
+import { Path } from './types/path';
+import { FieldErrors } from './types/errors';
+type UseFormArg<T extends FormValues> = {
+    defaultValues: T;
+    mode?: "onInput" | "onChange" | "onSubmit";
+};
+type SubmitCallback<T extends FormValues> = (values: T) => void;
+type Rules = {
+    required: boolean;
+};
+export declare const useForm: <T extends FormValues>({ defaultValues, mode, }: UseFormArg<T>) => {
+    errors: import('solid-js').Accessor<FieldErrors<T>>;
+    isValid: import('solid-js').Accessor<boolean>;
+    register: (name: Path<T>, options?: Rules) => {
+        name: Path<T>;
+        value: any;
+        onInput(event: InputEvent): void;
+        onChange(event: Event): void;
+        ref: (ref: HTMLInputElement | null) => void;
+    };
+    getValues: (name?: Path<T>) => any;
+    setValue: (name: Path<T>, value: any) => void;
+    onSubmit: (submit: SubmitCallback<T>) => (event: SubmitEvent) => void;
+    reset: (newDefaultValues?: Partial<T>) => void;
+};
+export {};

package/package.json ADDED Viewed

@@ -0,0 +1,49 @@
+{
+  "name": "solid-hook-form",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "./dist/main.umd.cjs",
+  "module": "./dist/main.js",
+  "types": "./dist/main.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/main.js",
+      "require": "./dist/main.umd.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "solid-js": "^1.9.5"
+  },
+  "devDependencies": {
+    "react-hook-form": "^7.55.0",
+    "typescript": "~5.7.2",
+    "vite": "^6.0.11",
+    "vite-plugin-dts": "^4.5.0",
+    "vitest": "^3.0.5"
+  },
+  "scripts": {
+    "build": "tsc && vite build",
+    "test": "vitest run"
+  },
+  "author": "thorn_pear",
+  "license": "ISC",
+  "description": "Performant, flexible and extensible forms library for Solid",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tatsmaki/solid-hook-form.git"
+  },
+  "keywords": [
+    "solid",
+    "hooks",
+    "form",
+    "forms",
+    "form-validation",
+    "validation",
+    "typescript",
+    "solid-hooks"
+  ]
+}