flemo 1.0.0

package/dist/navigate/store.d.ts

@@ -0,0 +1,7 @@
+export type NavigateStatus = "IDLE" | "PUSHING" | "REPLACING" | "POPPING" | "COMPLETED";
+interface NavigateStore {
+    status: NavigateStatus;
+    setStatus: (status: NavigateStatus) => void;
+}
+declare const useNavigateStore: import('zustand').UseBoundStore<import('zustand').StoreApi<NavigateStore>>;
+export default useNavigateStore;

package/dist/navigate/useNavigate.d.ts

@@ -0,0 +1,11 @@
+import { RegisterRoute } from '../Route';
+import { TransitionName } from '../transition/typing';
+export default function useNavigate(): {
+    push: <T extends keyof RegisterRoute>(path: T, params: RegisterRoute[T], options?: {
+        transitionName?: TransitionName;
+    }) => Promise<void>;
+    replace: <T extends keyof RegisterRoute>(path: T, params: RegisterRoute[T], options?: {
+        transitionName?: TransitionName;
+    }) => Promise<void>;
+    pop: () => void;
+};

package/dist/navigate/useStep.d.ts

@@ -0,0 +1,6 @@
+import { RegisterRoute } from '../Route';
+export default function useStep<T extends keyof RegisterRoute>(): {
+    pushStep: (params: RegisterRoute[T]) => Promise<void>;
+    replaceStep: (params: RegisterRoute[T]) => Promise<void>;
+    popStep: () => void;
+};

package/dist/renderer/Renderer.d.ts

@@ -0,0 +1,3 @@
+import { PropsWithChildren } from 'react';
+declare function Renderer({ children }: PropsWithChildren): import("react").JSX.Element[];
+export default Renderer;

package/dist/screen/ParamsProvider/ParamsContext.d.ts

@@ -0,0 +1,2 @@
+declare const ParamsContext: import('react').Context<object>;
+export default ParamsContext;

package/dist/screen/ParamsProvider/ParamsDispatchContext.d.ts

@@ -0,0 +1,7 @@
+import { Dispatch } from 'react';
+export interface ParamsDispatchContextType {
+    type: "SET";
+    params: object;
+}
+declare const ParamsDispatchContext: import('react').Context<Dispatch<ParamsDispatchContextType>>;
+export default ParamsDispatchContext;

package/dist/screen/ParamsProvider/ParamsProvider.d.ts

@@ -0,0 +1,6 @@
+import { PropsWithChildren } from 'react';
+declare function ParamsProvider({ children, active, params }: PropsWithChildren<{
+    active: boolean;
+    params: object;
+}>): import("react").JSX.Element;
+export default ParamsProvider;

package/dist/screen/ParamsProvider/ParamsReducer.d.ts

@@ -0,0 +1,3 @@
+import { ParamsDispatchContextType } from './ParamsDispatchContext';
+declare function ParamsReducer(state: object, action: ParamsDispatchContextType): object;
+export default ParamsReducer;

package/dist/screen/ParamsProvider/useParams.d.ts

@@ -0,0 +1,2 @@
+import { RegisterRoute } from '../../Route';
+export default function useParams<T extends keyof RegisterRoute>(): RegisterRoute[T];

package/dist/screen/ParamsProvider/useParamsDispatch.d.ts

@@ -0,0 +1 @@
+export default function useParamsDispatch(): import('react').Dispatch<import('./ParamsDispatchContext').ParamsDispatchContextType>;

package/dist/screen/Screen.d.ts

@@ -0,0 +1,3 @@
+import { ComponentPropsWithRef } from 'react';
+declare function Screen({ children, ...props }: ComponentPropsWithRef<"div">): import("react").JSX.Element;
+export default Screen;

package/dist/screen/ScreenContext.d.ts

@@ -0,0 +1,12 @@
+import { History } from '../history/store';
+import { TransitionName } from '../transition/typing';
+export interface ScreenContextProps extends History {
+    id: string;
+    isActive: boolean;
+    isRoot: boolean;
+    isPrev: boolean;
+    zIndex: number;
+    prevTransitionName: TransitionName;
+}
+declare const ScreenContext: import('react').Context<ScreenContextProps>;
+export default ScreenContext;

package/dist/screen/ScreenFreeze.d.ts

@@ -0,0 +1,8 @@
+import { ReactNode } from 'react';
+interface ScreenFreezeProps {
+    freeze: boolean;
+    children: ReactNode;
+    placeholder?: ReactNode;
+}
+declare function ScreenFreeze({ freeze, children, placeholder }: ScreenFreezeProps): import("react").JSX.Element;
+export default ScreenFreeze;

package/dist/screen/ScreenMotion.d.ts

@@ -0,0 +1,3 @@
+import { ComponentPropsWithRef } from 'react';
+declare function ScreenMotion({ children, ...props }: ComponentPropsWithRef<"div">): import("react").JSX.Element;
+export default ScreenMotion;

package/dist/screen/ScreenMotionDecorator.d.ts

@@ -0,0 +1,3 @@
+import { ComponentPropsWithRef } from 'react';
+declare function ScreenMotionDecorator({ children, ref, ...props }: ComponentPropsWithRef<"div">): import("react").JSX.Element;
+export default ScreenMotionDecorator;

package/dist/screen/store.d.ts

@@ -0,0 +1,6 @@
+interface ScreenStore {
+    transitionStatus: "IDLE" | "PENDING";
+    setTransitionStatus: (transitionStatus: "IDLE" | "PENDING") => void;
+}
+declare const useScreenStore: import('zustand').UseBoundStore<import('zustand').StoreApi<ScreenStore>>;
+export default useScreenStore;

package/dist/screen/useScreen.d.ts

@@ -0,0 +1 @@
+export default function useScreen(): import('./ScreenContext').ScreenContextProps;

package/dist/transition/createRawTransition.d.ts

@@ -0,0 +1,18 @@
+import { TransitionOptions, Transition, TransitionVariantValue, TransitionName } from './typing';
+import { TargetAndTransition } from 'motion';
+interface CreateRawTransitionProps {
+    name: TransitionName;
+    initial: TargetAndTransition;
+    idle: TransitionVariantValue;
+    pushOnEnter: TransitionVariantValue;
+    pushOnExit: TransitionVariantValue;
+    replaceOnEnter: TransitionVariantValue;
+    replaceOnExit: TransitionVariantValue;
+    popOnEnter: TransitionVariantValue;
+    popOnExit: TransitionVariantValue;
+    completedOnEnter: TransitionVariantValue;
+    completedOnExit: TransitionVariantValue;
+    options?: TransitionOptions;
+}
+export default function createRawTransition({ name, initial, idle, pushOnEnter, pushOnExit, replaceOnEnter, replaceOnExit, popOnEnter, popOnExit, completedOnExit, completedOnEnter, options }: CreateRawTransitionProps): Transition;
+export {};

package/dist/transition/createTransition.d.ts

@@ -0,0 +1,14 @@
+import { TransitionOptions, Transition, TransitionVariantValue, TransitionName } from './typing';
+import { TargetAndTransition } from 'motion';
+interface CreateTransitionProps {
+    name: TransitionName;
+    initial: TargetAndTransition;
+    idle: TransitionVariantValue;
+    enter: TransitionVariantValue;
+    enterBack: TransitionVariantValue;
+    exit: TransitionVariantValue;
+    exitBack: TransitionVariantValue;
+    options?: TransitionOptions;
+}
+export default function createTransition({ name, initial, idle, enter, enterBack, exit, exitBack, options }: CreateTransitionProps): Transition;
+export {};

package/dist/transition/cupertino.d.ts

@@ -0,0 +1,2 @@
+declare const cupertino: import('./typing').Transition;
+export default cupertino;

package/dist/transition/decorator/createDecorator.d.ts

@@ -0,0 +1,12 @@
+import { DecoratorName, Decorator, DecoratorOptions } from './typing';
+import { TransitionVariantValue } from '../typing';
+import { TargetAndTransition } from 'motion';
+interface CreateDecoratorProps {
+    name: DecoratorName;
+    initial: TargetAndTransition;
+    enter: TransitionVariantValue;
+    exit: TransitionVariantValue;
+    options?: DecoratorOptions;
+}
+export default function createDecorator({ name, initial, enter, exit, options }: CreateDecoratorProps): Decorator;
+export {};

package/dist/transition/decorator/createRawDecorator.d.ts

@@ -0,0 +1,19 @@
+import { TransitionVariantValue } from '../typing';
+import { DecoratorName, Decorator, DecoratorOptions } from './typing';
+import { TargetAndTransition } from 'motion';
+interface CreateRawDecoratorProps {
+    name: DecoratorName;
+    initial: TargetAndTransition;
+    idle: TransitionVariantValue;
+    pushOnEnter: TransitionVariantValue;
+    pushOnExit: TransitionVariantValue;
+    replaceOnEnter: TransitionVariantValue;
+    replaceOnExit: TransitionVariantValue;
+    popOnEnter: TransitionVariantValue;
+    popOnExit: TransitionVariantValue;
+    completedOnEnter: TransitionVariantValue;
+    completedOnExit: TransitionVariantValue;
+    options?: DecoratorOptions;
+}
+export default function createRawDecorator({ name, initial, idle, pushOnEnter, pushOnExit, replaceOnEnter, replaceOnExit, popOnEnter, popOnExit, completedOnEnter, completedOnExit, options }: CreateRawDecoratorProps): Decorator;
+export {};

package/dist/transition/decorator/decorator.d.ts

@@ -0,0 +1,2 @@
+import { Decorator } from './typing';
+export declare const decoratorMap: Map<"overlay", Decorator>;

package/dist/transition/decorator/overlay.d.ts

@@ -0,0 +1,2 @@
+declare const overlay: import('./typing').Decorator;
+export default overlay;

package/dist/transition/decorator/typing.d.ts

@@ -0,0 +1,13 @@
+import { BaseTransition } from '../typing';
+export interface RegisterDecorator {
+}
+export type DecoratorName = RegisterDecorator[keyof RegisterDecorator] | "overlay";
+export type DecoratorOptions = {
+    onSwipe?: (progress: number, options: {
+        currentDecorator: HTMLDivElement;
+        prevDecorator: HTMLDivElement;
+    }) => void;
+};
+export interface Decorator extends Omit<BaseTransition, "name">, DecoratorOptions {
+    name: DecoratorName;
+}

package/dist/transition/material.d.ts

@@ -0,0 +1,2 @@
+declare const material: import('./typing').Transition;
+export default material;

package/dist/transition/none.d.ts

@@ -0,0 +1,2 @@
+declare const none: import('./typing').Transition;
+export default none;

package/dist/transition/store.d.ts

@@ -0,0 +1,7 @@
+import { TransitionName } from './typing';
+interface TransitionStore {
+    defaultTransitionName: TransitionName;
+    setDefaultTransitionName: (defaultTransitionName: TransitionName) => void;
+}
+declare const useTransitionStore: import('zustand').UseBoundStore<import('zustand').StoreApi<TransitionStore>>;
+export default useTransitionStore;

package/dist/transition/transition.d.ts

@@ -0,0 +1,3 @@
+import { TransitionName, Transition } from './typing';
+export declare const transitionMap: Map<TransitionName, Transition>;
+export declare const transitionInitialValue: Record<string, unknown>;

package/dist/transition/typing.d.ts

@@ -0,0 +1,38 @@
+import { PanInfo, TargetAndTransition, Target, AnimationOptions, DragControls } from 'motion/react';
+import { NavigateStatus } from '../navigate/store';
+import { DecoratorName } from './decorator/typing';
+export interface RegisterTransition {
+}
+export type TransitionName = RegisterTransition[keyof RegisterTransition] | "none" | "cupertino" | "material";
+export type TransitionVariant = `${NavigateStatus}-${boolean}`;
+export type TransitionVariantValue = {
+    value: Target;
+    options: AnimationOptions;
+};
+export type TransitionOptions = {
+    decoratorName?: DecoratorName;
+    swipeDirection: "x" | "y";
+    onSwipeStart: (event: MouseEvent | TouchEvent | PointerEvent, info: PanInfo, options: {
+        currentScreen: HTMLDivElement;
+        prevScreen: HTMLDivElement;
+        dragControls: DragControls;
+    }) => Promise<void>;
+    onSwipe: (event: MouseEvent | TouchEvent | PointerEvent, info: PanInfo, options: {
+        currentScreen: HTMLDivElement;
+        prevScreen: HTMLDivElement;
+        dragControls: DragControls;
+    }) => number;
+    onSwipeEnd: (event: MouseEvent | TouchEvent | PointerEvent, info: PanInfo, options: {
+        currentScreen: HTMLDivElement;
+        prevScreen: HTMLDivElement;
+    }) => Promise<boolean>;
+} | {
+    decoratorName?: DecoratorName;
+    swipeDirection?: never;
+};
+export interface BaseTransition {
+    name: TransitionName;
+    initial: TargetAndTransition;
+    variants: Record<TransitionVariant, TransitionVariantValue>;
+}
+export type Transition = BaseTransition & TransitionOptions;

package/dist/utils/getParams.d.ts

@@ -0,0 +1,4 @@
+import { Path } from 'path-to-regexp';
+export default function getParams(paths: Path | Path[], path: string, search: string): {
+    [x: string]: string;
+};

package/dist/utils/isServer.d.ts

@@ -0,0 +1 @@
+export default function isServer(): boolean;

package/dist/vendor-C8cPYUOQ.js

@@ -0,0 +1,299 @@
+import C from "react";
+var d = {}, N;
+function H() {
+  if (N) return d;
+  N = 1, Object.defineProperty(d, "__esModule", { value: !0 }), d.TokenData = void 0, d.parse = m, d.compile = R, d.match = M, d.pathToRegexp = j, d.stringify = k;
+  const c = "/", a = (n) => n, l = /^[$_\p{ID_Start}]$/u, h = /^[$\u200c\u200d\p{ID_Continue}]$/u, $ = "https://git.new/pathToRegexpError", b = {
+    // Groups.
+    "{": "{",
+    "}": "}",
+    // Reserved.
+    "(": "(",
+    ")": ")",
+    "[": "[",
+    "]": "]",
+    "+": "+",
+    "?": "?",
+    "!": "!"
+  };
+  function _(n) {
+    return n.replace(/[{}()\[\]+?!:*]/g, "\\$&");
+  }
+  function f(n) {
+    return n.replace(/[.+*?^${}()[\]|/\\]/g, "\\$&");
+  }
+  function* I(n) {
+    const t = [...n];
+    let e = 0;
+    function o() {
+      let r = "";
+      if (l.test(t[++e]))
+        for (r += t[e]; h.test(t[++e]); )
+          r += t[e];
+      else if (t[e] === '"') {
+        let s = e;
+        for (; e < t.length; ) {
+          if (t[++e] === '"') {
+            e++, s = 0;
+            break;
+          }
+          t[e] === "\\" ? r += t[++e] : r += t[e];
+        }
+        if (s)
+          throw new TypeError(`Unterminated quote at ${s}: ${$}`);
+      }
+      if (!r)
+        throw new TypeError(`Missing parameter name at ${e}: ${$}`);
+      return r;
+    }
+    for (; e < t.length; ) {
+      const r = t[e], s = b[r];
+      if (s)
+        yield { type: s, index: e++, value: r };
+      else if (r === "\\")
+        yield { type: "ESCAPED", index: e++, value: t[e++] };
+      else if (r === ":") {
+        const u = o();
+        yield { type: "PARAM", index: e, value: u };
+      } else if (r === "*") {
+        const u = o();
+        yield { type: "WILDCARD", index: e, value: u };
+      } else
+        yield { type: "CHAR", index: e, value: t[e++] };
+    }
+    return { type: "END", index: e, value: "" };
+  }
+  class g {
+    constructor(t) {
+      this.tokens = t;
+    }
+    peek() {
+      if (!this._peek) {
+        const t = this.tokens.next();
+        this._peek = t.value;
+      }
+      return this._peek;
+    }
+    tryConsume(t) {
+      const e = this.peek();
+      if (e.type === t)
+        return this._peek = void 0, e.value;
+    }
+    consume(t) {
+      const e = this.tryConsume(t);
+      if (e !== void 0)
+        return e;
+      const { type: o, index: r } = this.peek();
+      throw new TypeError(`Unexpected ${o} at ${r}, expected ${t}: ${$}`);
+    }
+    text() {
+      let t = "", e;
+      for (; e = this.tryConsume("CHAR") || this.tryConsume("ESCAPED"); )
+        t += e;
+      return t;
+    }
+  }
+  class x {
+    constructor(t) {
+      this.tokens = t;
+    }
+  }
+  d.TokenData = x;
+  function m(n, t = {}) {
+    const { encodePath: e = a } = t, o = new g(I(n));
+    function r(u) {
+      const i = [];
+      for (; ; ) {
+        const p = o.text();
+        p && i.push({ type: "text", value: e(p) });
+        const y = o.tryConsume("PARAM");
+        if (y) {
+          i.push({
+            type: "param",
+            name: y
+          });
+          continue;
+        }
+        const S = o.tryConsume("WILDCARD");
+        if (S) {
+          i.push({
+            type: "wildcard",
+            name: S
+          });
+          continue;
+        }
+        if (o.tryConsume("{")) {
+          i.push({
+            type: "group",
+            tokens: r("}")
+          });
+          continue;
+        }
+        return o.consume(u), i;
+      }
+    }
+    const s = r("END");
+    return new x(s);
+  }
+  function R(n, t = {}) {
+    const { encode: e = encodeURIComponent, delimiter: o = c } = t, r = n instanceof x ? n : m(n, t), s = T(r.tokens, o, e);
+    return function(i = {}) {
+      const [p, ...y] = s(i);
+      if (y.length)
+        throw new TypeError(`Missing parameters: ${y.join(", ")}`);
+      return p;
+    };
+  }
+  function T(n, t, e) {
+    const o = n.map((r) => P(r, t, e));
+    return (r) => {
+      const s = [""];
+      for (const u of o) {
+        const [i, ...p] = u(r);
+        s[0] += i, s.push(...p);
+      }
+      return s;
+    };
+  }
+  function P(n, t, e) {
+    if (n.type === "text")
+      return () => [n.value];
+    if (n.type === "group") {
+      const r = T(n.tokens, t, e);
+      return (s) => {
+        const [u, ...i] = r(s);
+        return i.length ? [""] : [u];
+      };
+    }
+    const o = e || a;
+    return n.type === "wildcard" && e !== !1 ? (r) => {
+      const s = r[n.name];
+      if (s == null)
+        return ["", n.name];
+      if (!Array.isArray(s) || s.length === 0)
+        throw new TypeError(`Expected "${n.name}" to be a non-empty array`);
+      return [
+        s.map((u, i) => {
+          if (typeof u != "string")
+            throw new TypeError(`Expected "${n.name}/${i}" to be a string`);
+          return o(u);
+        }).join(t)
+      ];
+    } : (r) => {
+      const s = r[n.name];
+      if (s == null)
+        return ["", n.name];
+      if (typeof s != "string")
+        throw new TypeError(`Expected "${n.name}" to be a string`);
+      return [o(s)];
+    };
+  }
+  function M(n, t = {}) {
+    const { decode: e = decodeURIComponent, delimiter: o = c } = t, { regexp: r, keys: s } = j(n, t), u = s.map((i) => e === !1 ? a : i.type === "param" ? e : (p) => p.split(o).map(e));
+    return function(p) {
+      const y = r.exec(p);
+      if (!y)
+        return !1;
+      const S = y[0], w = /* @__PURE__ */ Object.create(null);
+      for (let E = 1; E < y.length; E++) {
+        if (y[E] === void 0)
+          continue;
+        const v = s[E - 1], A = u[E - 1];
+        w[v.name] = A(y[E]);
+      }
+      return { path: S, params: w };
+    };
+  }
+  function j(n, t = {}) {
+    const { delimiter: e = c, end: o = !0, sensitive: r = !1, trailing: s = !0 } = t, u = [], i = [], p = r ? "" : "i", S = (Array.isArray(n) ? n : [n]).map((v) => v instanceof x ? v : m(v, t));
+    for (const { tokens: v } of S)
+      for (const A of D(v, 0, [])) {
+        const B = L(A, e, u);
+        i.push(B);
+      }
+    let w = `^(?:${i.join("|")})`;
+    return s && (w += `(?:${f(e)}$)?`), w += o ? "$" : `(?=${f(e)}|$)`, { regexp: new RegExp(w, p), keys: u };
+  }
+  function* D(n, t, e) {
+    if (t === n.length)
+      return yield e;
+    const o = n[t];
+    if (o.type === "group") {
+      const r = e.slice();
+      for (const s of D(o.tokens, 0, r))
+        yield* D(n, t + 1, s);
+    } else
+      e.push(o);
+    yield* D(n, t + 1, e);
+  }
+  function L(n, t, e) {
+    let o = "", r = "", s = !0;
+    for (let u = 0; u < n.length; u++) {
+      const i = n[u];
+      if (i.type === "text") {
+        o += f(i.value), r += i.value, s || (s = i.value.includes(t));
+        continue;
+      }
+      if (i.type === "param" || i.type === "wildcard") {
+        if (!s && !r)
+          throw new TypeError(`Missing text after "${i.name}": ${$}`);
+        i.type === "param" ? o += `(${q(t, s ? "" : r)}+)` : o += "([\\s\\S]+)", e.push(i), r = "", s = !1;
+        continue;
+      }
+    }
+    return o;
+  }
+  function q(n, t) {
+    return t.length < 2 ? n.length < 2 ? `[^${f(n + t)}]` : `(?:(?!${f(n)})[^${f(t)}])` : n.length < 2 ? `(?:(?!${f(t)})[^${f(n)}])` : `(?:(?!${f(t)}|${f(n)})[\\s\\S])`;
+  }
+  function k(n) {
+    return n.tokens.map(function t(e, o, r) {
+      if (e.type === "text")
+        return _(e.value);
+      if (e.type === "group")
+        return `{${e.tokens.map(t).join("")}}`;
+      const u = F(e.name) && V(r[o + 1]) ? e.name : JSON.stringify(e.name);
+      if (e.type === "param")
+        return `:${u}`;
+      if (e.type === "wildcard")
+        return `*${u}`;
+      throw new TypeError(`Unexpected token: ${e}`);
+    }).join("");
+  }
+  function F(n) {
+    const [t, ...e] = n;
+    return l.test(t) ? e.every((o) => h.test(o)) : !1;
+  }
+  function V(n) {
+    return n?.type !== "text" ? !0 : !h.test(n.value[0]);
+  }
+  return d;
+}
+var z = H();
+const O = (c) => {
+  let a;
+  const l = /* @__PURE__ */ new Set(), h = (g, x) => {
+    const m = typeof g == "function" ? g(a) : g;
+    if (!Object.is(m, a)) {
+      const R = a;
+      a = x ?? (typeof m != "object" || m === null) ? m : Object.assign({}, a, m), l.forEach((T) => T(a, R));
+    }
+  }, $ = () => a, f = { setState: h, getState: $, getInitialState: () => I, subscribe: (g) => (l.add(g), () => l.delete(g)) }, I = a = c(h, $, f);
+  return f;
+}, W = (c) => c ? O(c) : O, G = (c) => c;
+function J(c, a = G) {
+  const l = C.useSyncExternalStore(
+    c.subscribe,
+    C.useCallback(() => a(c.getState()), [c, a]),
+    C.useCallback(() => a(c.getInitialState()), [c, a])
+  );
+  return C.useDebugValue(l), l;
+}
+const U = (c) => {
+  const a = W(c), l = (h) => J(a, h);
+  return Object.assign(l, a), l;
+}, Q = (c) => c ? U(c) : U;
+export {
+  Q as c,
+  z as d
+};

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "flemo",
+  "version": "1.0.0",
+  "description": "A modern React router with smooth motion transitions and a seamless flow between screens",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "keywords": [
+    "flemo",
+    "react",
+    "react-router",
+    "motion",
+    "transition",
+    "page-transition",
+    "react-page-transition"
+  ],
+  "author": {
+    "name": "kimjh96",
+    "email": "kimjhs@kakao.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kimjh96/flemo.git"
+  },
+  "bugs": {
+    "url": "https://github.com/kimjh96/flemo/issues",
+    "email": "kimjhs@kakao.com"
+  },
+  "homepage": "https://flemo-web.vercel.app",
+  "license": "MIT",
+  "scripts": {
+    "build": "vite build",
+    "watch": "vite build --watch",
+    "prettier": "prettier --write --config ./.prettierrc \"**/*.{js,mjs,ts,jsx,tsx,mts,json}\"",
+    "convention": "pnpm prettier && eslint --fix \"**/*.{js,mjs,ts,jsx,tsx,mts,html}\"",
+    "prepare": "husky",
+    "prepublishOnly": "pnpm build"
+  },
+  "dependencies": {
+    "path-to-regexp": "^8.2.0",
+    "zustand": "^5.0.7"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.33.0",
+    "@types/node": "^24.3.0",
+    "@types/react": "^19.1.10",
+    "@types/react-dom": "^19.1.7",
+    "@vitejs/plugin-react-swc": "^4.0.0",
+    "eslint": "^9.33.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "globals": "^16.3.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.1.5",
+    "prettier": "^3.6.2",
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.39.1",
+    "vite": "^7.1.2",
+    "vite-plugin-dts": "^4.5.4"
+  },
+  "peerDependencies": {
+    "motion": "^12.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "lint-staged": {
+    "*.{js,mjs,ts,jsx,tsx,mts,json}": "prettier --write",
+    "*.{js,mjs,ts,jsx,tsx,mts,html}": "eslint --fix"
+  }
+}