@yeongseoksong/framework 1.2.0 → 1.4.0

package/dist/store/index.d.ts

@@ -0,0 +1,207 @@
+import * as zustand_middleware from 'zustand/middleware';
+import * as zustand from 'zustand';
+import { ReactNode, FormEvent } from 'react';
+
+/**
+ * 로그인한 사용자. 소비자 앱의 사용자 모델이 더 넓으면 `login()`에 넘기기 전에
+ * 이 형태로 좁혀서 넣는다 — 스토어는 화면이 필요로 하는 최소 정보만 갖는다.
+ */
+interface AuthUser {
+    id: string;
+    email: string;
+    name?: string;
+    roles?: string[];
+}
+interface AuthState {
+    user: AuthUser | null;
+    /** user의 파생값이지만, 셀렉터를 `(s) => s.isAuthenticated` 한 줄로 유지하려고 상태로 둔다. */
+    isAuthenticated: boolean;
+    /** localStorage 복원이 끝났는지. 정적 프리렌더 대비용 — 아래 주석 참고. */
+    hasHydrated: boolean;
+    login: (user: AuthUser) => void;
+    logout: () => void;
+    setHasHydrated: (value: boolean) => void;
+}
+/**
+ * 인증 세션.
+ *
+ * **액세스 토큰을 여기 넣지 말 것.** `partialize`가 사용자 프로필만 저장하도록
+ * 막아 두었다. 토큰은 httpOnly 쿠키로 두는 게 소비자 앱의 몫이다 — localStorage에
+ * 담으면 XSS 한 번에 그대로 털린다.
+ *
+ * `skipHydration`을 켠 이유: 자동 복원은 모듈 평가 시점에 일어나서 **첫 클라이언트
+ * 렌더가 이미 로그인 상태**가 된다. 반면 서버가 만든 HTML에는 항상 로그아웃 상태가
+ * 박혀 나가므로(`output: "export"`면 빌드 시점에 고정) 하이드레이션 불일치가 난다.
+ * 복원을 이펙트로 미루면 첫 렌더가 서버와 일치하고, 그 다음 틱에 세션이 반영된다.
+ * 복원을 트리거하고 완료 여부를 돌려주는 게 아래 `useAuthHydrated()`다.
+ */
+declare const useAuthStore: zustand.UseBoundStore<Omit<zustand.StoreApi<AuthState>, "setState" | "persist"> & {
+    setState(partial: AuthState | Partial<AuthState> | ((state: AuthState) => AuthState | Partial<AuthState>), replace?: false | undefined): unknown;
+    setState(state: AuthState | ((state: AuthState) => AuthState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<zustand_middleware.PersistOptions<AuthState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: AuthState) => void) => () => void;
+        onFinishHydration: (fn: (state: AuthState) => void) => () => void;
+        getOptions: () => Partial<zustand_middleware.PersistOptions<AuthState, unknown, unknown>>;
+    };
+}>;
+/**
+ * 저장된 세션을 복원하고, 복원이 끝났는지를 돌려준다.
+ *
+ * 로그인 여부에 따라 다르게 그리는 UI는 이 값이 `false`인 동안 **로그아웃 상태로**
+ * 그려야 서버 HTML과 어긋나지 않는다.
+ *
+ * ```tsx
+ * const hydrated = useAuthHydrated()
+ * const isAuthenticated = useAuthStore((s) => s.isAuthenticated)
+ * if (hydrated && isAuthenticated) { ... }
+ * ```
+ */
+declare function useAuthHydrated(): boolean;
+
+interface UiState {
+    /** 전역 로딩 오버레이 — 라우트 전환·일괄 작업처럼 화면 전체를 막아야 할 때 */
+    globalLoading: boolean;
+    setGlobalLoading: (value: boolean) => void;
+    /** 관리자형 레이아웃의 사이드 내비 열림 상태 */
+    sideNavOpened: boolean;
+    openSideNav: () => void;
+    closeSideNav: () => void;
+    toggleSideNav: () => void;
+}
+/**
+ * 화면 간 공유가 필요한 클라이언트 UI 상태.
+ *
+ * `SdHeader`의 모바일 드로어는 **일부러 여기 두지 않는다.** 그건 인스턴스 로컬
+ * 상태(`useDisclosure`)여야 한다 — 카탈로그처럼 한 페이지에 헤더가 둘 이상 렌더되면
+ * 스토어를 공유하는 순간 드로어가 함께 열린다.
+ */
+declare const useUiStore: zustand.UseBoundStore<zustand.StoreApi<UiState>>;
+
+/**
+ * 어떤 작업이 끝난 뒤 항상 돌려야 하는 뒷정리 — 라우팅, 모달 닫기, 목록 새로고침 등.
+ *
+ * 폼에 딸린 개념이 아니다. 제출·삭제·업로드처럼 "끝나면 정리한다"가 필요한 곳이면
+ * 어느 스토어에서든 같은 타입과 실행기를 쓴다.
+ */
+/**
+ * 뒷정리 함수. **인자를 받지 않는다** — 대개 결과와 무관한 정리·이동이라
+ * 기존 함수(`close`, `refetch`, `() => router.push('/')`)를 그대로 꽂을 수 있어야 한다.
+ * 반환값은 무시하고, 프로미스면 기다린다.
+ */
+type Finalizer = () => unknown | Promise<unknown>;
+/** 하나 또는 여러 개. 여러 개면 넘긴 순서대로 실행된다. */
+type Finalizers = Finalizer | Finalizer[];
+
+/**
+ * 모든 폼이 공유하는 상태 + 제출 파이프라인.
+ *
+ * 폼 하나하나가 `useState`로 값·에러·제출중 여부를 따로 들고 있으면 제출 처리(중복
+ * 클릭 차단, 성공/실패 알림, 성공 후 초기화)가 폼마다 조금씩 달라진다. 그 셋을 여기
+ * 한 곳에 묶어 두고, 화면은 `useSdForm()` 하나만 부르면 되게 한다.
+ *
+ * 스토어는 `formId`로 칸을 나눠 쓰므로 한 화면에 폼이 여러 개 떠 있어도 섞이지 않고,
+ * 반대로 **같은 id를 쓰면 서로 다른 컴포넌트가 같은 폼을 공유**한다(마법사 단계 분리,
+ * 페이지를 오간 뒤 입력값 복원 등).
+ */
+type FormValues = Record<string, unknown>;
+/** 값이 유효하면 `null`, 아니면 사용자에게 보여줄 메시지를 돌려준다. */
+type FormRule<V extends FormValues> = (value: unknown, values: V) => string | null;
+type FormErrors<V extends FormValues> = Partial<Record<keyof V, string>>;
+interface FormEntry {
+    values: FormValues;
+    errors: Record<string, string>;
+    submitting: boolean;
+    /** 제출 실패 메시지 — 폼 상단에 노출한다. 필드 에러는 `errors`가 담는다. */
+    error: ReactNode | null;
+}
+interface FormStoreState {
+    forms: Record<string, FormEntry>;
+    /** 첫 마운트 시 초기값을 심는다. 이미 있으면 건드리지 않는다(입력값 보존). */
+    ensureForm: (formId: string, initialValues: FormValues) => void;
+    setValue: (formId: string, name: string, value: unknown) => void;
+    setValues: (formId: string, values: FormValues) => void;
+    setErrors: (formId: string, errors: Record<string, string>) => void;
+    setSubmitting: (formId: string, submitting: boolean) => void;
+    setError: (formId: string, error: ReactNode | null) => void;
+    resetForm: (formId: string, initialValues: FormValues) => void;
+    /** 폼 칸 자체를 버린다 — 값까지 지우고 싶을 때만. */
+    removeForm: (formId: string) => void;
+}
+declare const useFormStore: zustand.UseBoundStore<zustand.StoreApi<FormStoreState>>;
+interface SdFormOptions<V extends FormValues> {
+    /** 스토어에서 이 폼이 쓸 칸의 이름. 같은 id를 쓰는 컴포넌트끼리는 상태를 공유한다. */
+    id: string;
+    initialValues: V;
+    /** 필드별 검증 규칙. 제출 시 한 번에 돌린다. */
+    rules?: Partial<Record<keyof V, FormRule<V>>>;
+    /** 실제 전송. 예외를 던지면 실패로 처리된다(에러 토스트 + 폼 상단 메시지). */
+    onSubmit: (values: V) => void | Promise<void>;
+    /** 성공 토스트 메시지. `false`면 토스트를 띄우지 않는다. */
+    successMessage?: ReactNode | false;
+    /** 실패 메시지 변환. 기본값은 `Error.message`, 없으면 일반 문구. */
+    errorMessage?: (error: unknown) => ReactNode;
+    /** 성공 후 초기값으로 되돌릴지 */
+    resetOnSuccess?: boolean;
+    onSuccess?: (values: V) => void;
+    /** 전송이 실패했을 때. 예외를 그대로 받는다. */
+    onError?: (error: unknown) => void;
+    /**
+     * 성공·실패와 무관하게 전송이 끝나면 **항상** 실행된다 — `finally`에 해당한다.
+     * 라우팅, 모달 닫기, 목록 새로고침처럼 결과와 무관한 뒷정리 자리다.
+     *
+     * 타입은 폼 전용이 아니라 공용 `Finalizers`(`util/finalize.util.ts`)다 — 인자를 받지
+     * 않으므로 기존 함수를 그대로 꽂고(`finalize: closeModal`), 여러 개는 배열로 묶는다.
+     * 결과에 따라 갈라져야 하는 일은 `onSuccess` / `onError`에 둔다.
+     *
+     * 검증에서 걸려 전송 자체를 하지 않은 경우에는 실행되지 않는다(아직 "끝난" 게 아니다).
+     * `submitting`이 내려간 **뒤에** 실행되므로, 여기서 `reset()`이나 다른 제출을 불러도 안전하다.
+     */
+    finalize?: Finalizers;
+}
+interface SdFormApi<V extends FormValues> {
+    values: V;
+    errors: FormErrors<V>;
+    /** 전송 중 — 버튼 `loading`에 그대로 넘긴다. 이 동안 재제출은 무시된다. */
+    submitting: boolean;
+    /** 제출 실패 메시지 */
+    error: ReactNode | null;
+    setValue: <K extends keyof V>(name: K, value: V[K]) => void;
+    setValues: (values: Partial<V>) => void;
+    reset: () => void;
+    /** Mantine 입력 컴포넌트에 펼쳐 넣는다. 체크박스는 `{ type: 'checkbox' }`. */
+    getInputProps: (name: keyof V, options?: {
+        type?: 'input' | 'checkbox';
+    }) => Record<string, unknown>;
+    /** `<form onSubmit={...}>`에 그대로 넘긴다. */
+    onSubmit: (event?: FormEvent<HTMLFormElement>) => void;
+}
+/**
+ * 폼 하나를 스토어에 붙이고, 값·에러·제출을 한 묶음으로 돌려준다.
+ *
+ * 제출은 항상 같은 순서로 흐른다:
+ * 검증 → (통과 시) submitting on → `onSubmit` → 성공 토스트·초기화·`onSuccess`
+ * → 실패 시 에러 토스트 + 상단 메시지·`onError` → submitting off → `finalize`.
+ */
+declare function useSdForm<V extends FormValues>({ id, initialValues, rules, onSubmit, successMessage, errorMessage, resetOnSuccess, onSuccess, onError, finalize, }: SdFormOptions<V>): SdFormApi<V>;
+/**
+ * 자주 쓰는 검증 규칙. `rules`에 그대로 꽂아 쓴다.
+ *
+ * ```ts
+ * rules: { email: formRules.email(), password: formRules.minLength(8) }
+ * ```
+ */
+declare const formRules: {
+    required: <V extends FormValues>(message?: string) => FormRule<V>;
+    email: <V extends FormValues>(message?: string) => FormRule<V>;
+    minLength: <V extends FormValues>(length: number, message?: string) => FormRule<V>;
+    /** 체크박스 동의 — 반드시 true여야 한다. */
+    checked: <V extends FormValues>(message?: string) => FormRule<V>;
+    /** 다른 필드와 같은 값인지 — 비밀번호 확인 등. */
+    sameAs: <V extends FormValues>(other: keyof V, message?: string) => FormRule<V>;
+};
+
+export { type AuthUser, type FormErrors, type FormRule, type FormValues, type SdFormApi, type SdFormOptions, formRules, useAuthHydrated, useAuthStore, useFormStore, useSdForm, useUiStore };

package/dist/store/index.mjs

@@ -0,0 +1,355 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __restKey = (key) => typeof key === "symbol" ? key : key + "";
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// store/auth.store.ts
+import { useEffect } from "react";
+import { create } from "zustand";
+import { createJSONStorage, persist } from "zustand/middleware";
+var useAuthStore = create()(
+  persist(
+    (set) => ({
+      user: null,
+      isAuthenticated: false,
+      hasHydrated: false,
+      login: (user) => set({ user, isAuthenticated: true }),
+      logout: () => set({ user: null, isAuthenticated: false }),
+      setHasHydrated: (value) => set({ hasHydrated: value })
+    }),
+    {
+      name: "sd-auth",
+      storage: createJSONStorage(() => localStorage),
+      partialize: (state) => ({ user: state.user, isAuthenticated: state.isAuthenticated }),
+      skipHydration: true,
+      onRehydrateStorage: () => (state) => state == null ? void 0 : state.setHasHydrated(true)
+    }
+  )
+);
+var rehydrateStarted = false;
+function useAuthHydrated() {
+  const hasHydrated = useAuthStore((state) => state.hasHydrated);
+  useEffect(() => {
+    if (rehydrateStarted) return;
+    rehydrateStarted = true;
+    void useAuthStore.persist.rehydrate();
+  }, []);
+  return hasHydrated;
+}
+
+// store/ui.store.ts
+import { create as create2 } from "zustand";
+var useUiStore = create2()((set) => ({
+  globalLoading: false,
+  setGlobalLoading: (value) => set({ globalLoading: value }),
+  sideNavOpened: false,
+  openSideNav: () => set({ sideNavOpened: true }),
+  closeSideNav: () => set({ sideNavOpened: false }),
+  toggleSideNav: () => set((state) => ({ sideNavOpened: !state.sideNavOpened }))
+}));
+
+// store/form.state.ts
+import { useCallback, useEffect as useEffect2, useMemo } from "react";
+import { create as create3 } from "zustand";
+
+// ui/atom/Toast.tsx
+import { Notifications, notifications } from "@mantine/notifications";
+import { IconAlertTriangle, IconCheck, IconInfoCircle, IconX } from "@tabler/icons-react";
+import { jsx } from "react/jsx-runtime";
+var toastStyles = {
+  /** 성공 — 저장·전송 완료 */
+  Success: { color: "green", icon: /* @__PURE__ */ jsx(IconCheck, { size: 18 }), title: "\uC644\uB8CC" },
+  /** 실패 — 요청 오류·검증 실패 */
+  Error: { color: "red", icon: /* @__PURE__ */ jsx(IconX, { size: 18 }), title: "\uC624\uB958" },
+  /** 주의 — 되돌릴 수 없는 동작 안내 등 */
+  Warning: { color: "amber", icon: /* @__PURE__ */ jsx(IconAlertTriangle, { size: 18 }), title: "\uC8FC\uC758" },
+  /** 안내 — 중립 정보 */
+  Info: { color: "primary", icon: /* @__PURE__ */ jsx(IconInfoCircle, { size: 18 }), title: "\uC548\uB0B4" },
+  /** 진행 중 — 스피너 + 자동 닫힘 없음. Update로 결과 변형으로 바꾼다. */
+  Loading: { loading: true, autoClose: false, withCloseButton: false, title: "\uCC98\uB9AC \uC911" }
+};
+function createToast(defaults) {
+  return function SdToast2(message, options) {
+    return notifications.show(__spreadValues(__spreadProps(__spreadValues({}, defaults), { message }), options));
+  };
+}
+var SdToast = {
+  Success: createToast(toastStyles.Success),
+  Error: createToast(toastStyles.Error),
+  Warning: createToast(toastStyles.Warning),
+  Info: createToast(toastStyles.Info),
+  Loading: createToast(toastStyles.Loading),
+  /**
+   * 이미 떠 있는 알림을 다른 변형으로 교체한다 — `Loading` → `Success`/`Error` 전환용.
+   * `loading: false`·`autoClose`를 먼저 깔아 두므로 스피너가 그대로 남지 않는다.
+   */
+  Update: (id, variant, message, options) => notifications.update(__spreadValues(__spreadProps(__spreadValues({
+    id,
+    loading: false,
+    autoClose: 4e3,
+    withCloseButton: true
+  }, toastStyles[variant]), {
+    message
+  }), options)),
+  /** 특정 알림 닫기 */
+  Hide: (id) => notifications.hide(id),
+  /** 떠 있는 알림 전부 닫기 */
+  Clean: () => notifications.clean()
+};
+var SdToastSuccess = SdToast.Success;
+var SdToastError = SdToast.Error;
+var SdToastWarning = SdToast.Warning;
+var SdToastInfo = SdToast.Info;
+var SdToastLoading = SdToast.Loading;
+var SdToastUpdate = SdToast.Update;
+var SdToastHide = SdToast.Hide;
+var SdToastClean = SdToast.Clean;
+
+// util/finalize.util.ts
+function runFinalizers(finalize, label = "finalize") {
+  return __async(this, null, function* () {
+    if (!finalize) return;
+    const list = Array.isArray(finalize) ? finalize : [finalize];
+    for (const fn of list) {
+      try {
+        yield fn();
+      } catch (caught) {
+        console.error(`[${label}] finalize\uC5D0\uC11C \uC608\uC678\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4.`, caught);
+      }
+    }
+  });
+}
+
+// store/form.state.ts
+var EMPTY_ERRORS = {};
+function readChangePayload(payload) {
+  if (payload && typeof payload === "object" && "currentTarget" in payload) {
+    const target = payload.currentTarget;
+    if (target && typeof target === "object" && "value" in target) {
+      return target.type === "checkbox" ? target.checked : target.value;
+    }
+  }
+  return payload;
+}
+function blankEntry(values) {
+  return { values, errors: {}, submitting: false, error: null };
+}
+function patch(state, formId, next) {
+  const current = state.forms[formId];
+  if (!current) return state;
+  return __spreadProps(__spreadValues({}, state), { forms: __spreadProps(__spreadValues({}, state.forms), { [formId]: __spreadValues(__spreadValues({}, current), next) }) });
+}
+var useFormStore = create3()((set) => ({
+  forms: {},
+  ensureForm: (formId, initialValues) => set(
+    (state) => state.forms[formId] ? state : __spreadProps(__spreadValues({}, state), { forms: __spreadProps(__spreadValues({}, state.forms), { [formId]: blankEntry(initialValues) }) })
+  ),
+  setValue: (formId, name, value) => set((state) => {
+    const current = state.forms[formId];
+    if (!current) return state;
+    const _a = current.errors, { [name]: _removed } = _a, restErrors = __objRest(_a, [__restKey(name)]);
+    return patch(state, formId, {
+      values: __spreadProps(__spreadValues({}, current.values), { [name]: value }),
+      errors: restErrors
+    });
+  }),
+  setValues: (formId, values) => set((state) => {
+    const current = state.forms[formId];
+    if (!current) return state;
+    return patch(state, formId, { values: __spreadValues(__spreadValues({}, current.values), values) });
+  }),
+  setErrors: (formId, errors) => set((state) => patch(state, formId, { errors })),
+  setSubmitting: (formId, submitting) => set((state) => patch(state, formId, { submitting })),
+  setError: (formId, error) => set((state) => patch(state, formId, { error })),
+  resetForm: (formId, initialValues) => set((state) => __spreadProps(__spreadValues({}, state), { forms: __spreadProps(__spreadValues({}, state.forms), { [formId]: blankEntry(initialValues) }) })),
+  removeForm: (formId) => set((state) => {
+    const _a = state.forms, { [formId]: _removed } = _a, rest = __objRest(_a, [__restKey(formId)]);
+    return __spreadProps(__spreadValues({}, state), { forms: rest });
+  })
+}));
+function useSdForm({
+  id,
+  initialValues,
+  rules,
+  onSubmit,
+  successMessage,
+  errorMessage,
+  resetOnSuccess,
+  onSuccess,
+  onError,
+  finalize
+}) {
+  var _a, _b, _c, _d;
+  const entry = useFormStore((state) => state.forms[id]);
+  const store = useFormStore;
+  useEffect2(() => {
+    store.getState().ensureForm(id, initialValues);
+  }, [id]);
+  const values = (_a = entry == null ? void 0 : entry.values) != null ? _a : initialValues;
+  const errors = (_b = entry == null ? void 0 : entry.errors) != null ? _b : EMPTY_ERRORS;
+  const submitting = (_c = entry == null ? void 0 : entry.submitting) != null ? _c : false;
+  const error = (_d = entry == null ? void 0 : entry.error) != null ? _d : null;
+  const setValue = useCallback(
+    (name, value) => store.getState().setValue(id, String(name), value),
+    [id, store]
+  );
+  const setValues = useCallback(
+    (next) => store.getState().setValues(id, next),
+    [id, store]
+  );
+  const reset = useCallback(
+    () => store.getState().resetForm(id, initialValues),
+    // initialValues 참조가 바뀌어도 reset의 의미는 같다.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [id, store]
+  );
+  const getInputProps = useCallback(
+    (name, options) => {
+      const key = String(name);
+      const fieldError = errors[name];
+      const current = values[name];
+      const onChange = (payload) => store.getState().setValue(id, key, readChangePayload(payload));
+      if ((options == null ? void 0 : options.type) === "checkbox") {
+        return { checked: Boolean(current), error: fieldError, onChange };
+      }
+      return {
+        // undefined일 때만 ''로 메운다 — null은 그대로 둬야 Select·Date가 "값 없음"으로 읽는다.
+        value: current === void 0 ? "" : current,
+        error: fieldError,
+        onChange
+      };
+    },
+    [errors, id, store, values]
+  );
+  const handleSubmit = useCallback(
+    (event) => __async(null, null, function* () {
+      var _a2, _b2;
+      event == null ? void 0 : event.preventDefault();
+      const state = store.getState();
+      const current = state.forms[id];
+      if (current == null ? void 0 : current.submitting) return;
+      const currentValues = (_a2 = current == null ? void 0 : current.values) != null ? _a2 : initialValues;
+      if (rules) {
+        const found = {};
+        for (const [name, rule] of Object.entries(rules)) {
+          const message = rule == null ? void 0 : rule(currentValues[name], currentValues);
+          if (message) found[name] = message;
+        }
+        if (Object.keys(found).length > 0) {
+          state.setErrors(id, found);
+          return;
+        }
+      }
+      state.setErrors(id, {});
+      state.setError(id, null);
+      state.setSubmitting(id, true);
+      try {
+        yield onSubmit(currentValues);
+        if (successMessage !== false) SdToast.Success(successMessage != null ? successMessage : "\uC800\uC7A5\uD588\uC2B5\uB2C8\uB2E4.");
+        if (resetOnSuccess) state.resetForm(id, initialValues);
+        onSuccess == null ? void 0 : onSuccess(currentValues);
+      } catch (caught) {
+        const message = (_b2 = errorMessage == null ? void 0 : errorMessage(caught)) != null ? _b2 : caught instanceof Error ? caught.message : "\uC694\uCCAD\uC744 \uCC98\uB9AC\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.";
+        state.setError(id, message);
+        SdToast.Error(message);
+        onError == null ? void 0 : onError(caught);
+      } finally {
+        store.getState().setSubmitting(id, false);
+        yield runFinalizers(finalize, "useSdForm");
+      }
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      id,
+      store,
+      rules,
+      onSubmit,
+      successMessage,
+      errorMessage,
+      resetOnSuccess,
+      onSuccess,
+      onError,
+      finalize
+    ]
+  );
+  return useMemo(
+    () => ({
+      values,
+      errors,
+      submitting,
+      error,
+      setValue,
+      setValues,
+      reset,
+      getInputProps,
+      onSubmit: handleSubmit
+    }),
+    [values, errors, submitting, error, setValue, setValues, reset, getInputProps, handleSubmit]
+  );
+}
+var formRules = {
+  required: (message = "\uD544\uC218 \uC785\uB825 \uD56D\uBAA9\uC785\uB2C8\uB2E4.") => (value) => value === void 0 || value === null || String(value).trim() === "" ? message : null,
+  email: (message = "\uC774\uBA54\uC77C \uD615\uC2DD\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.") => (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(value != null ? value : "")) ? null : message,
+  minLength: (length, message) => (value) => String(value != null ? value : "").length >= length ? null : message != null ? message : `${length}\uC790 \uC774\uC0C1 \uC785\uB825\uD558\uC138\uC694.`,
+  /** 체크박스 동의 — 반드시 true여야 한다. */
+  checked: (message = "\uB3D9\uC758\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4.") => (value) => value === true ? null : message,
+  /** 다른 필드와 같은 값인지 — 비밀번호 확인 등. */
+  sameAs: (other, message = "\uAC12\uC774 \uC77C\uCE58\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.") => (value, values) => value === values[other] ? null : message
+};
+export {
+  formRules,
+  useAuthHydrated,
+  useAuthStore,
+  useFormStore,
+  useSdForm,
+  useUiStore
+};