@k8o/arte-odyssey 0.0.0

package/dist/helpers/color/find-all-colors.d.ts

@@ -0,0 +1,12 @@
+/**
+ * テキスト文字列内のすべての色の値とその位置を見つけます。
+ * HSL、RGB、RGBA、HSLA、HEX、名前付き色をサポートします。
+ *
+ * @param text - 色の値を検索するテキスト
+ * @returns 色の値、開始位置、終了位置を含む色オブジェクトの配列
+ */
+export declare function findAllColors(text: string): {
+    color: string;
+    start: number;
+    end: number;
+}[];

package/dist/helpers/color/find-all-colors.js

@@ -0,0 +1,210 @@
+function findAllColors(text) {
+  const results = [];
+  function extractFunctionContent(text2, funcName) {
+    const funcPattern = new RegExp(`${funcName}\\s*\\(`, "gi");
+    const matches = [];
+    let match = funcPattern.exec(text2);
+    while (match !== null) {
+      const startIndex = match.index + match[0].length - 1;
+      let depth = 0;
+      let endIndex = -1;
+      for (let i = startIndex; i < text2.length; i++) {
+        if (text2[i] === "(") {
+          depth++;
+        } else if (text2[i] === ")") {
+          depth--;
+          if (depth === 0) {
+            endIndex = i;
+            break;
+          }
+        }
+      }
+      if (endIndex !== -1) {
+        const content = text2.substring(startIndex + 1, endIndex);
+        const fullColor = `${funcName.toLowerCase()}(${content})`;
+        matches.push({
+          color: fullColor,
+          start: match.index,
+          end: endIndex + 1
+        });
+      }
+      match = funcPattern.exec(text2);
+    }
+    return matches;
+  }
+  const colorFunctions = ["hsl", "rgb", "rgba", "hsla"];
+  for (const func of colorFunctions) {
+    const matches = extractFunctionContent(text, func);
+    results.push(...matches);
+  }
+  const hexPattern = /#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})(?=\s|;|,|$|\)|]|})/g;
+  let hexMatch = hexPattern.exec(text);
+  while (hexMatch !== null) {
+    results.push({
+      color: hexMatch[0],
+      start: hexMatch.index,
+      end: hexMatch.index + hexMatch[0].length
+    });
+    hexMatch = hexPattern.exec(text);
+  }
+  const namedColors = [
+    "red",
+    "blue",
+    "green",
+    "yellow",
+    "orange",
+    "purple",
+    "pink",
+    "brown",
+    "black",
+    "white",
+    "gray",
+    "grey",
+    "cyan",
+    "magenta",
+    "lime",
+    "navy",
+    "maroon",
+    "olive",
+    "teal",
+    "silver",
+    "gold",
+    "indigo",
+    "violet"
+  ];
+  const lowerText = text.toLowerCase();
+  for (const color of namedColors) {
+    let startIndex = 0;
+    let index = lowerText.indexOf(color, startIndex);
+    while (index !== -1) {
+      const beforeChar = index > 0 ? lowerText[index - 1] ?? " " : " ";
+      const afterChar = index + color.length < lowerText.length ? lowerText[index + color.length] ?? " " : " ";
+      if (/\s|;|,|:/.test(beforeChar) && /\s|;|,|$|\)|]|}/.test(afterChar)) {
+        results.push({
+          color,
+          start: index,
+          end: index + color.length
+        });
+      }
+      startIndex = index + 1;
+      index = lowerText.indexOf(color, startIndex);
+    }
+  }
+  results.sort((a, b) => a.start - b.start);
+  const filteredResults = [];
+  for (const result of results) {
+    const hasOverlap = filteredResults.some(
+      (existing) => result.start >= existing.start && result.start < existing.end || result.end > existing.start && result.end <= existing.end || result.start <= existing.start && result.end >= existing.end
+    );
+    if (!hasOverlap) {
+      filteredResults.push(result);
+    }
+  }
+  return filteredResults;
+}
+if (import.meta.vitest) {
+  const { describe, expect, it } = import.meta.vitest;
+  describe("findAllColors", () => {
+    describe("\u5358\u4E00\u306E\u8272\u306E\u5834\u5408", () => {
+      it("HSL\u8272\u3092\u898B\u3064\u3051\u308B", () => {
+        const result = findAllColors("hsl(280, 70%, 50%)");
+        expect(result).toEqual([
+          { color: "hsl(280, 70%, 50%)", start: 0, end: 18 }
+        ]);
+      });
+      it("HEX\u8272\u3092\u898B\u3064\u3051\u308B", () => {
+        const result = findAllColors("#ff0080");
+        expect(result).toEqual([{ color: "#ff0080", start: 0, end: 7 }]);
+      });
+      it("\u540D\u524D\u4ED8\u304D\u8272\u3092\u898B\u3064\u3051\u308B", () => {
+        const result = findAllColors("background-color: red;");
+        expect(result).toEqual([{ color: "red", start: 18, end: 21 }]);
+      });
+    });
+    describe("\u8907\u6570\u306E\u8272\u306E\u5834\u5408", () => {
+      it("\u7570\u306A\u308B\u5F62\u5F0F\u306E\u8907\u6570\u306E\u8272\u3092\u898B\u3064\u3051\u308B", () => {
+        const result = findAllColors(
+          "border: 1px solid #ff0080; background: hsl(280, 70%, 50%); color: white;"
+        );
+        expect(result).toEqual([
+          { color: "#ff0080", start: 18, end: 25 },
+          { color: "hsl(280, 70%, 50%)", start: 39, end: 57 },
+          { color: "white", start: 66, end: 71 }
+        ]);
+      });
+      it("gradient\u5185\u306E\u8907\u6570\u306E\u8272\u3092\u898B\u3064\u3051\u308B", () => {
+        const result = findAllColors(
+          "linear-gradient(45deg, #ff0080, hsl(280, 70%, 50%), rgba(255, 0, 128, 0.5))"
+        );
+        expect(result).toEqual([
+          { color: "#ff0080", start: 23, end: 30 },
+          { color: "hsl(280, 70%, 50%)", start: 32, end: 50 },
+          { color: "rgba(255, 0, 128, 0.5)", start: 52, end: 74 }
+        ]);
+      });
+    });
+    describe("\u91CD\u8907\u3059\u308B\u8272\u30D1\u30BF\u30FC\u30F3\u306E\u5834\u5408", () => {
+      it("\u95A2\u6570\u578B\u8272\u3092\u540D\u524D\u4ED8\u304D\u8272\u3088\u308A\u512A\u5148\u3059\u308B", () => {
+        const result = findAllColors("rgb(255, 0, 0) red");
+        expect(result).toEqual([
+          { color: "rgb(255, 0, 0)", start: 0, end: 14 },
+          { color: "red", start: 15, end: 18 }
+        ]);
+      });
+      it("\u91CD\u8907\u3059\u308B\u9818\u57DF\u3067\u306F\u6700\u521D\u306E\u8272\u306E\u307F\u3092\u4FDD\u6301\u3059\u308B", () => {
+        const result = findAllColors("background-color: red");
+        expect(result).toEqual([{ color: "red", start: 18, end: 21 }]);
+      });
+    });
+    describe("\u8907\u96D1\u306ACSS\u95A2\u6570\u306E\u5834\u5408", () => {
+      it("calc\u5F0F\u3092\u542B\u3080HSL\u8272\u3092\u898B\u3064\u3051\u308B", () => {
+        const result = findAllColors("hsl(calc(var(--hue) + 50), 70%, 50%)");
+        expect(result).toEqual([
+          {
+            color: "hsl(calc(var(--hue) + 50), 70%, 50%)",
+            start: 0,
+            end: 36
+          }
+        ]);
+      });
+      it("\u30CD\u30B9\u30C8\u3057\u305F\u62EC\u5F27\u3092\u542B\u3080\u8272\u3092\u898B\u3064\u3051\u308B", () => {
+        const result = findAllColors(
+          "hsl(calc(sign(var(--x)) * 80 + 200), 70%, 50%)"
+        );
+        expect(result).toEqual([
+          {
+            color: "hsl(calc(sign(var(--x)) * 80 + 200), 70%, 50%)",
+            start: 0,
+            end: 46
+          }
+        ]);
+      });
+    });
+    describe("\u8272\u304C\u898B\u3064\u304B\u3089\u306A\u3044\u5834\u5408", () => {
+      it("\u7A7A\u306E\u914D\u5217\u3092\u8FD4\u3059", () => {
+        const result = findAllColors("transform: translateX(100px);");
+        expect(result).toEqual([]);
+      });
+      it("\u8272\u3067\u306A\u3044\u30C6\u30AD\u30B9\u30C8\u3067\u306F\u7A7A\u306E\u914D\u5217\u3092\u8FD4\u3059", () => {
+        const result = findAllColors("font-size: 16px; margin: 10px;");
+        expect(result).toEqual([]);
+      });
+    });
+    describe("\u30A8\u30C3\u30B8\u30B1\u30FC\u30B9", () => {
+      it("\u540C\u3058\u8272\u304C\u8907\u6570\u56DE\u51FA\u73FE\u3059\u308B\u5834\u5408", () => {
+        const result = findAllColors("color: red; border-color: red;");
+        expect(result).toEqual([
+          { color: "red", start: 7, end: 10 },
+          { color: "red", start: 26, end: 29 }
+        ]);
+      });
+      it("\u6587\u5B57\u5217\u306E\u5883\u754C\u3067\u306E\u8272\u691C\u51FA", () => {
+        const result = findAllColors("red");
+        expect(result).toEqual([{ color: "red", start: 0, end: 3 }]);
+      });
+    });
+  });
+}
+export {
+  findAllColors
+};

package/dist/helpers/is-internal-route.d.ts

@@ -0,0 +1 @@
+export declare const isInternalRoute: (href: string) => boolean;

package/dist/helpers/is-internal-route.js

@@ -0,0 +1,12 @@
+const isInternalRoute = (href) => !href.startsWith("http");
+if (import.meta.vitest) {
+  it("http\u304B\u3089\u59CB\u307E\u308Bhref\u306Fexternal\u306A\u3082\u306E\u3068\u3057\u3066\u5224\u5B9A\u3059\u308B", () => {
+    expect(isInternalRoute("https://k8o.me/dummy")).toBe(false);
+  });
+  it("http\u304B\u3089\u59CB\u307E\u3089\u306A\u3044href\u306Fexternal\u306A\u3082\u306E\u3068\u3057\u3066\u5224\u5B9A\u3059\u308B", () => {
+    expect(isInternalRoute("/dummy")).toBe(true);
+  });
+}
+export {
+  isInternalRoute
+};

package/dist/helpers/number/between.d.ts

@@ -0,0 +1 @@
+export declare const between: (value: number, min: number, max: number) => number;

package/dist/helpers/number/between.js

@@ -0,0 +1,19 @@
+const between = (value, min, max) => {
+  return Math.min(Math.max(value, min), max);
+};
+if (import.meta.vitest) {
+  describe("between", () => {
+    it("min\u3068max\u306E\u9593\u306E\u5024\u306E\u5834\u5408\u306F\u305D\u306E\u307E\u307E\u8FD4\u3059", () => {
+      expect(between(5, 0, 10)).toBe(5);
+    });
+    it("min\u3088\u308A\u5C0F\u3055\u3044\u5834\u5408\u306Fmin\u3092\u8FD4\u3059", () => {
+      expect(between(-5, 0, 10)).toBe(0);
+    });
+    it("max\u3088\u308A\u5927\u304D\u3044\u5834\u5408\u306Fmax\u3092\u8FD4\u3059", () => {
+      expect(between(15, 0, 10)).toBe(10);
+    });
+  });
+}
+export {
+  between
+};

package/dist/helpers/number/cast.d.ts

@@ -0,0 +1 @@
+export declare const cast: (value: string, step: number, precision?: number) => number;

package/dist/helpers/number/cast.js

@@ -0,0 +1,41 @@
+import { toPrecision } from "./to-precision";
+const FLOATING_POINT_REGEX = /^[Ee0-9+\-.]$/;
+const isInvalidCharacter = (value) => {
+  return FLOATING_POINT_REGEX.test(value);
+};
+const sanitize = (value) => value.split("").filter(isInvalidCharacter).join("");
+const parse = (value) => {
+  return Number.parseFloat(value.toString().replace(/[^\w.-]+/g, ""));
+};
+const countDecimalPlaces = (value) => {
+  if (!Number.isFinite(value)) return 0;
+  let e = 1;
+  let p = 0;
+  while (Math.round(value * e) / e !== value) {
+    e *= 10;
+    p += 1;
+  }
+  return p;
+};
+const cast = (value, step, precision) => {
+  const parsedValue = parse(sanitize(value));
+  if (Number.isNaN(parsedValue)) return 0;
+  const decimalPlaces = Math.max(
+    countDecimalPlaces(step),
+    countDecimalPlaces(parsedValue)
+  );
+  return toPrecision(parsedValue, precision ?? decimalPlaces);
+};
+if (import.meta.vitest) {
+  it("\u6587\u5B57\u3092\u6570\u5024\u306B\u5909\u63DB\u3059\u308B", () => {
+    expect(cast("1", 1)).toBe(1);
+    expect(cast("1.1", 1)).toBe(1.1);
+    expect(cast("1.1.1", 1)).toBe(1.1);
+    expect(cast("1.1.1", 2)).toBe(1.1);
+    expect(cast("1e4", 3)).toBe(1e4);
+    expect(cast("-19", 3)).toBe(-19);
+  });
+}
+export {
+  cast
+};

package/dist/helpers/number/commalize.d.ts

@@ -0,0 +1 @@
+export declare const commalize: (num: number) => string;

package/dist/helpers/number/commalize.js

@@ -0,0 +1,22 @@
+const commalize = (num) => {
+  const roundedNumber = Math.round(num);
+  const numberString = roundedNumber.toString();
+  return numberString.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+};
+if (import.meta.vitest) {
+  it("3\u6841\u672A\u6E80\u306E\u5834\u5408\u306F\u305D\u306E\u307E\u307E\u8FD4\u3059", () => {
+    expect(commalize(100)).toBe("100");
+  });
+  it("4\u6841\u306E\u5834\u5408\u306F\u30AB\u30F3\u30DE\u533A\u5207\u308A\u306B\u3059\u308B", () => {
+    expect(commalize(1e3)).toBe("1,000");
+  });
+  it("3\u6841\u6BCE\u306B\u30AB\u30F3\u30DE\u533A\u5207\u308A\u306B\u3059\u308B", () => {
+    expect(commalize(1e6)).toBe("1,000,000");
+  });
+  it("\u5C11\u6570\u306E\u5834\u5408\u306F\u56DB\u6368\u4E94\u5165\u3057\u3066\u6574\u6570\u306B\u3059\u308B", () => {
+    expect(commalize(1000.5)).toBe("1,001");
+  });
+}
+export {
+  commalize
+};

package/dist/helpers/number/index.d.ts

@@ -0,0 +1,4 @@
+export { between } from './between';
+export { cast } from './cast';
+export { commalize } from './commalize';
+export { toPrecision } from './to-precision';

package/dist/helpers/number/index.js

@@ -0,0 +1,10 @@
+import { between } from "./between";
+import { cast } from "./cast";
+import { commalize } from "./commalize";
+import { toPrecision } from "./to-precision";
+export {
+  between,
+  cast,
+  commalize,
+  toPrecision
+};

package/dist/helpers/number/to-precision.d.ts

@@ -0,0 +1 @@
+export declare const toPrecision: (value: number, precision?: number) => number;

package/dist/helpers/number/to-precision.js

@@ -0,0 +1,17 @@
+const toPrecision = (value, precision) => {
+  const scaleFactor = 10 ** (precision ?? 10);
+  return Math.round(value * scaleFactor) / scaleFactor;
+};
+if (import.meta.vitest) {
+  it("\u6570\u5024\u3092\u6307\u5B9A\u3057\u305F\u6841\u6570\u306B\u4E38\u3081\u308B", () => {
+    expect(toPrecision(1.2345, 0)).toBe(1);
+    expect(toPrecision(1.2345, 1)).toBe(1.2);
+    expect(toPrecision(1.2345, 2)).toBe(1.23);
+    expect(toPrecision(1.2345, 3)).toBe(1.235);
+    expect(toPrecision(1.2345, 4)).toBe(1.2345);
+    expect(toPrecision(1.2345, 5)).toBe(1.2345);
+  });
+}
+export {
+  toPrecision
+};

package/dist/helpers/uuid-v4.d.ts

@@ -0,0 +1 @@
+export declare const uuidV4: () => string;

package/dist/helpers/uuid-v4.js

@@ -0,0 +1,32 @@
+const HEX_BASE = 16;
+const uuidV4 = () => {
+  if (typeof window !== "undefined" && isSecureContext) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const randHex = Math.floor(Math.random() * HEX_BASE);
+    if (c === "y") {
+      return (randHex & 3 | 8).toString(HEX_BASE);
+    }
+    return randHex.toString(HEX_BASE);
+  });
+};
+if (import.meta.vitest) {
+  const testRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  beforeEach(() => {
+    vi.unstubAllGlobals();
+  });
+  it("\u5B89\u5168\u306A\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u3067\u306FrandUUID\u304B\u3089uuidv4\u3092\u8FD4\u3059", () => {
+    vi.stubGlobal("isSecureContext", true);
+    const result = uuidV4();
+    expect(result).toMatch(testRegex);
+  });
+  it("\u5B89\u5168\u306A\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u5916\u3067\u306F\u81EA\u4F5C\u306Euuidv4\u3092\u8FD4\u3059", () => {
+    vi.stubGlobal("isSecureContext", false);
+    const result = uuidV4();
+    expect(result).toMatch(testRegex);
+  });
+}
+export {
+  uuidV4
+};

package/dist/hooks/click-away/index.d.ts

@@ -0,0 +1,2 @@
+import { type RefObject } from 'react';
+export declare const useClickAway: <T extends Element = HTMLElement>(callback: (e: Event) => void, enabled?: boolean) => RefObject<T | null>;

package/dist/hooks/click-away/index.js

@@ -0,0 +1,24 @@
+"use client";
+import { useEffect, useRef } from "react";
+const useClickAway = (callback, enabled = true) => {
+  const ref = useRef(null);
+  useEffect(() => {
+    if (!enabled) return;
+    const handler = (e) => {
+      const element = ref.current;
+      if (element && !element.contains(e.target)) {
+        callback(e);
+      }
+    };
+    document.addEventListener("mousedown", handler);
+    document.addEventListener("touchstart", handler);
+    return () => {
+      document.removeEventListener("mousedown", handler);
+      document.removeEventListener("touchstart", handler);
+    };
+  }, [callback, enabled]);
+  return ref;
+};
+export {
+  useClickAway
+};

package/dist/hooks/click-away/index.test.js

@@ -0,0 +1,31 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { fireEvent, render } from "@testing-library/react";
+import { useClickAway } from ".";
+const OutsideClicker = ({ callback }) => {
+  const ref = useClickAway(callback);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("div", { ref, children: "Element" }),
+    /* @__PURE__ */ jsx("div", { children: "Outside" })
+  ] });
+};
+describe("useClickAway", () => {
+  it("\u9818\u57DF\u5916\u3092\u89E6\u308B\u3068callback\u304C\u547C\u3073\u51FA\u3055\u308C\u308B", () => {
+    const fn = vi.fn();
+    const { getByText } = render(/* @__PURE__ */ jsx(OutsideClicker, { callback: fn }));
+    const element = getByText("Element");
+    const outsideElement = getByText("Outside");
+    const click = (el) => {
+      fireEvent.mouseDown(el);
+      fireEvent.mouseUp(el);
+    };
+    expect(fn).not.toHaveBeenCalled();
+    click(element);
+    expect(fn).not.toHaveBeenCalled();
+    click(outsideElement);
+    expect(fn).toHaveBeenCalledOnce();
+    click(document.body);
+    expect(fn).toHaveBeenCalledTimes(2);
+    click(document);
+    expect(fn).toHaveBeenCalledTimes(3);
+  });
+});

package/dist/hooks/client/index.d.ts

@@ -0,0 +1 @@
+export declare const useClient: () => boolean;

package/dist/hooks/client/index.js

@@ -0,0 +1,12 @@
+import { useSyncExternalStore } from "react";
+const useClient = () => {
+  return useSyncExternalStore(
+    () => () => {
+    },
+    () => true,
+    () => false
+  );
+};
+export {
+  useClient
+};

package/dist/hooks/clipboard/index.d.ts

@@ -0,0 +1,4 @@
+export declare const useClipboard: () => {
+    writeClipboard: (text: string) => Promise<void>;
+    readClipboard: () => Promise<string>;
+};

package/dist/hooks/clipboard/index.js

@@ -0,0 +1,17 @@
+import { useCallback } from "react";
+const useClipboard = () => {
+  const writeClipboard = useCallback(async (text) => {
+    await navigator.clipboard.writeText(text);
+  }, []);
+  const readClipboard = useCallback(async () => {
+    const text = await navigator.clipboard.readText();
+    return text;
+  }, []);
+  return {
+    writeClipboard,
+    readClipboard
+  };
+};
+export {
+  useClipboard
+};

package/dist/hooks/clipboard/index.test.js

@@ -0,0 +1,35 @@
+import { act, renderHook } from "@testing-library/react";
+import { useClipboard } from ".";
+describe("useClipboard", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+  it("\u30AF\u30EA\u30C3\u30D7\u30DC\u30FC\u30C9\u3092\u66F8\u304D\u8FBC\u3081\u308B", async () => {
+    const writeText = "test";
+    const writeTextMockFn = vi.fn();
+    vi.stubGlobal("navigator", {
+      clipboard: {
+        writeText: writeTextMockFn
+      }
+    });
+    const { result } = renderHook(() => useClipboard());
+    await act(async () => {
+      await result.current.writeClipboard(writeText);
+    });
+    expect(writeTextMockFn).toBeCalledWith(writeText);
+    expect(navigator.clipboard.writeText).toHaveBeenCalledOnce();
+  });
+  it("\u30AF\u30EA\u30C3\u30D7\u30DC\u30FC\u30C9\u3092\u8AAD\u307F\u8FBC\u3081\u308B", async () => {
+    const readTextMockFn = vi.fn();
+    vi.stubGlobal("navigator", {
+      clipboard: {
+        readText: readTextMockFn
+      }
+    });
+    const { result } = renderHook(() => useClipboard());
+    await act(async () => {
+      await result.current.readClipboard();
+    });
+    expect(readTextMockFn).toHaveBeenCalledOnce();
+  });
+});

package/dist/hooks/hash/index.d.ts

@@ -0,0 +1 @@
+export declare const useHash: () => string | null;

package/dist/hooks/hash/index.js

@@ -0,0 +1,28 @@
+import { useSyncExternalStore } from "react";
+const getHash = () => typeof window !== "undefined" ? decodeURIComponent(window.location.hash.replace("#", "")) : null;
+const subscribe = (callback) => {
+  const { pushState, replaceState } = window.history;
+  window.history.pushState = (...args) => {
+    pushState.apply(window.history, args);
+    setTimeout(callback);
+  };
+  window.history.replaceState = (...args) => {
+    replaceState.apply(window.history, args);
+    setTimeout(callback);
+  };
+  window.addEventListener("hashchange", callback);
+  return () => {
+    window.removeEventListener("hashchange", callback);
+  };
+};
+const useHash = () => {
+  const hash = useSyncExternalStore(
+    subscribe,
+    () => getHash(),
+    () => null
+  );
+  return hash;
+};
+export {
+  useHash
+};

package/dist/hooks/hash/index.test.js

@@ -0,0 +1,46 @@
+import { renderHook, waitFor } from "@testing-library/react";
+import { act } from "react";
+import { useHash } from ".";
+vi.mock("../client", () => ({
+  useClient: () => true
+}));
+describe("useHash", () => {
+  const realHash = window.location.hash;
+  beforeEach(() => {
+    window.location.hash = "#test";
+  });
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    window.location.hash = realHash;
+  });
+  it("\u73FE\u5728\u306Ehash\u5024\u3092\u53D6\u5F97\u3067\u304D\u308B", () => {
+    const { result } = renderHook(() => useHash());
+    expect(result.current).toBe("test");
+  });
+  it("hash\u5024\u304C\u5909\u66F4\u3055\u308C\u305F\u3068\u304D\u306B\u66F4\u65B0\u3055\u308C\u308B", () => {
+    const { result } = renderHook(() => useHash());
+    window.location.hash = "#changed";
+    act(() => {
+      window.dispatchEvent(new Event("hashchange"));
+    });
+    expect(result.current).toBe("changed");
+  });
+  it("pushState\u3067hash\u5024\u304C\u5909\u66F4\u3055\u308C\u305F\u3068\u304D\u306B\u66F4\u65B0\u3055\u308C\u308B", async () => {
+    const { result } = renderHook(() => useHash());
+    act(() => {
+      window.history.pushState({}, "", "/#pushed");
+    });
+    await waitFor(() => {
+      expect(result.current).toBe("pushed");
+    });
+  });
+  it("replaceState\u3067hash\u5024\u304C\u5909\u66F4\u3055\u308C\u305F\u3068\u304D\u306B\u66F4\u65B0\u3055\u308C\u308B", async () => {
+    const { result } = renderHook(() => useHash());
+    act(() => {
+      window.history.replaceState({}, "", "/#replaced");
+    });
+    await waitFor(() => {
+      expect(result.current).toBe("replaced");
+    });
+  });
+});

package/dist/hooks/index.d.ts

@@ -0,0 +1,10 @@
+export * from './click-away';
+export * from './client';
+export * from './clipboard';
+export * from './hash';
+export * from './interval';
+export * from './local-storage';
+export * from './scroll-direction';
+export * from './step';
+export * from './timeout';
+export * from './window-size';

package/dist/hooks/index.js

@@ -0,0 +1,10 @@
+export * from "./click-away";
+export * from "./client";
+export * from "./clipboard";
+export * from "./hash";
+export * from "./interval";
+export * from "./local-storage";
+export * from "./scroll-direction";
+export * from "./step";
+export * from "./timeout";
+export * from "./window-size";

package/dist/hooks/interval/index.d.ts

@@ -0,0 +1 @@
+export declare const useInterval: (callback: () => void, timeout: number) => void;