nihonput 0.1.0

package/dist/index.js

@@ -0,0 +1,948 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  PREFECTURES: () => PREFECTURES,
+  PREFECTURE_SHORT_NAMES: () => PREFECTURE_SHORT_NAMES,
+  addPhoneNumberHyphen: () => addPhoneNumberHyphen,
+  addPostalCodeHyphen: () => addPostalCodeHyphen,
+  containsFullWidthPhoneNumber: () => containsFullWidthPhoneNumber,
+  containsHiragana: () => containsHiragana,
+  containsKatakana: () => containsKatakana,
+  defaultErrorMessages: () => defaultErrorMessages,
+  isFullWidthPostalCode: () => isFullWidthPostalCode,
+  isHalfWidthPhoneNumber: () => isHalfWidthPhoneNumber,
+  isHalfWidthPostalCode: () => isHalfWidthPostalCode,
+  normalizePrefecture: () => normalizePrefecture,
+  toFullWidth: () => toFullWidth,
+  toFullWidthHyphen: () => toFullWidthHyphen,
+  toFullWidthNumbers: () => toFullWidthNumbers,
+  toHalfWidth: () => toHalfWidth,
+  toHalfWidthHyphen: () => toHalfWidthHyphen,
+  toHalfWidthNumbers: () => toHalfWidthNumbers,
+  toHiragana: () => toHiragana,
+  toKatakana: () => toKatakana,
+  useAddressField: () => useAddressField,
+  useNameField: () => useNameField,
+  usePhoneNumberField: () => usePhoneNumberField,
+  usePostalCodeField: () => usePostalCodeField,
+  usePrefectureField: () => usePrefectureField,
+  validateHiragana: () => validateHiragana,
+  validateKatakana: () => validateKatakana,
+  validatePhoneNumber: () => validatePhoneNumber,
+  validatePostalCode: () => validatePostalCode,
+  validatePrefecture: () => validatePrefecture
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/hooks/useNameField.ts
+var import_react = require("react");
+
+// src/types/index.ts
+var defaultErrorMessages = {
+  katakanaOnly: "\u30AB\u30BF\u30AB\u30CA\u3067\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+  hiraganaOnly: "\u3072\u3089\u304C\u306A\u3067\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+  invalidPostalCode: "\u6B63\u3057\u3044\u90F5\u4FBF\u756A\u53F7\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044\uFF08\u4F8B: 123-4567\uFF09",
+  invalidPrefecture: "\u6B63\u3057\u3044\u90FD\u9053\u5E9C\u770C\u540D\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+  invalidPhoneNumber: "\u6B63\u3057\u3044\u96FB\u8A71\u756A\u53F7\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+  invalidWidth: "\u6B63\u3057\u3044\u6587\u5B57\u5E45\u3067\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+  invalidFormat: "\u6B63\u3057\u3044\u5F62\u5F0F\u3067\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044"
+};
+
+// src/validators/katakana.ts
+function validateKatakana(value) {
+  if (!value) return true;
+  const katakanaRegex = /^[\u30A0-\u30FF\u3000\s]+$/;
+  return katakanaRegex.test(value);
+}
+function containsHiragana(value) {
+  if (!value) return false;
+  const hiraganaRegex = /[\u3040-\u309F]/;
+  return hiraganaRegex.test(value);
+}
+
+// src/normalizers/toKatakana.ts
+function toKatakana(value) {
+  if (!value) return value;
+  return value.replace(/[\u3040-\u309F]/g, (char) => {
+    return String.fromCharCode(char.charCodeAt(0) + 96);
+  });
+}
+
+// src/hooks/useNameField.ts
+function useNameField(options) {
+  const {
+    kanaMode,
+    normalizeOn = "blur",
+    validateOn = "blur",
+    errorMessages = {}
+  } = options;
+  const [value, setValue] = (0, import_react.useState)("");
+  const [error, setError] = (0, import_react.useState)(null);
+  const [isValidating, setIsValidating] = (0, import_react.useState)(false);
+  const isComposingRef = (0, import_react.useRef)(false);
+  const messages = {
+    katakanaOnly: errorMessages.katakanaOnly ?? defaultErrorMessages.katakanaOnly,
+    invalidFormat: errorMessages.invalidFormat ?? defaultErrorMessages.invalidFormat
+  };
+  const normalize = (0, import_react.useCallback)(
+    (val) => {
+      if (kanaMode === "auto-convert") {
+        return toKatakana(val);
+      }
+      return val;
+    },
+    [kanaMode]
+  );
+  const validate = (0, import_react.useCallback)(
+    (val) => {
+      if (!val) return null;
+      if (kanaMode === "error-on-hiragana") {
+        if (containsHiragana(val)) {
+          return messages.katakanaOnly;
+        }
+      }
+      if (!validateKatakana(val)) {
+        return messages.katakanaOnly;
+      }
+      return null;
+    },
+    [kanaMode, messages.katakanaOnly]
+  );
+  const handleChange = (0, import_react.useCallback)(
+    (e) => {
+      const newValue = e.target.value;
+      setValue(newValue);
+      if (isComposingRef.current) return;
+      if (normalizeOn === "change") {
+        setValue(normalize(newValue));
+      }
+      if (validateOn === "change") {
+        setIsValidating(true);
+        const validationError = validate(
+          normalizeOn === "change" ? normalize(newValue) : newValue
+        );
+        setError(validationError);
+        setIsValidating(false);
+      }
+    },
+    [normalize, validate, normalizeOn, validateOn]
+  );
+  const handleBlur = (0, import_react.useCallback)(
+    (e) => {
+      const currentValue = e.target.value;
+      if (normalizeOn === "blur") {
+        const normalized = normalize(currentValue);
+        setValue(normalized);
+        if (validateOn === "blur") {
+          setIsValidating(true);
+          setError(validate(normalized));
+          setIsValidating(false);
+        }
+      } else if (validateOn === "blur") {
+        setIsValidating(true);
+        setError(validate(currentValue));
+        setIsValidating(false);
+      }
+    },
+    [normalize, validate, normalizeOn, validateOn]
+  );
+  const handleCompositionStart = (0, import_react.useCallback)(
+    (_e) => {
+      isComposingRef.current = true;
+    },
+    []
+  );
+  const handleCompositionEnd = (0, import_react.useCallback)(
+    (e) => {
+      isComposingRef.current = false;
+      const currentValue = e.currentTarget.value;
+      if (normalizeOn === "compositionEnd") {
+        const normalized = normalize(currentValue);
+        setValue(normalized);
+        if (validateOn === "blur" || validateOn === "change") {
+          setIsValidating(true);
+          setError(validate(normalized));
+          setIsValidating(false);
+        }
+      }
+    },
+    [normalize, validate, normalizeOn, validateOn]
+  );
+  return {
+    value,
+    onChange: handleChange,
+    onBlur: handleBlur,
+    onCompositionStart: handleCompositionStart,
+    onCompositionEnd: handleCompositionEnd,
+    error,
+    isValidating,
+    isComposing: isComposingRef.current
+  };
+}
+
+// src/hooks/usePostalCodeField.ts
+var import_react2 = require("react");
+
+// src/validators/postalCode.ts
+function validatePostalCode(value) {
+  if (!value) return true;
+  const normalized = value.replace(/[０-９]/g, (s) => String.fromCharCode(s.charCodeAt(0) - 65248)).replace(/[ー－]/g, "-");
+  const postalCodeRegex = /^\d{3}-?\d{4}$/;
+  return postalCodeRegex.test(normalized);
+}
+function isHalfWidthPostalCode(value) {
+  if (!value) return true;
+  const halfWidthRegex = /^[\d-]+$/;
+  return halfWidthRegex.test(value);
+}
+function isFullWidthPostalCode(value) {
+  if (!value) return true;
+  const fullWidthRegex = /^[０-９ー－]+$/;
+  return fullWidthRegex.test(value);
+}
+
+// src/normalizers/toHalfWidth.ts
+function toHalfWidth(value) {
+  if (!value) return value;
+  return value.replace(/[\uFF01-\uFF5E]/g, (char) => {
+    return String.fromCharCode(char.charCodeAt(0) - 65248);
+  }).replace(/\u3000/g, " ");
+}
+function toHalfWidthNumbers(value) {
+  if (!value) return value;
+  return value.replace(/[０-９]/g, (char) => {
+    return String.fromCharCode(char.charCodeAt(0) - 65248);
+  });
+}
+function toHalfWidthHyphen(value) {
+  if (!value) return value;
+  return value.replace(/[ー－―]/g, "-");
+}
+
+// src/normalizers/toFullWidth.ts
+function toFullWidth(value) {
+  if (!value) return value;
+  return value.replace(/[\x21-\x7E]/g, (char) => {
+    return String.fromCharCode(char.charCodeAt(0) + 65248);
+  }).replace(/ /g, "\u3000");
+}
+function toFullWidthNumbers(value) {
+  if (!value) return value;
+  return value.replace(/[0-9]/g, (char) => {
+    return String.fromCharCode(char.charCodeAt(0) + 65248);
+  });
+}
+function toFullWidthHyphen(value) {
+  if (!value) return value;
+  return value.replace(/-/g, "\u30FC");
+}
+
+// src/normalizers/addHyphen.ts
+function addPostalCodeHyphen(value) {
+  if (!value) return value;
+  let normalized = toHalfWidthNumbers(value);
+  normalized = toHalfWidthHyphen(normalized);
+  const digitsOnly = normalized.replace(/-/g, "");
+  if (digitsOnly.length >= 4) {
+    return digitsOnly.slice(0, 3) + "-" + digitsOnly.slice(3, 7);
+  }
+  return digitsOnly;
+}
+function addPhoneNumberHyphen(value) {
+  if (!value) return value;
+  let normalized = toHalfWidthNumbers(value);
+  normalized = toHalfWidthHyphen(normalized);
+  const digitsOnly = normalized.replace(/-/g, "");
+  if (digitsOnly.length === 11) {
+    if (digitsOnly.startsWith("0")) {
+      return digitsOnly.slice(0, 3) + "-" + digitsOnly.slice(3, 7) + "-" + digitsOnly.slice(7);
+    }
+  } else if (digitsOnly.length === 10) {
+    if (digitsOnly.startsWith("0")) {
+      if (digitsOnly.startsWith("03") || digitsOnly.startsWith("06")) {
+        return digitsOnly.slice(0, 2) + "-" + digitsOnly.slice(2, 6) + "-" + digitsOnly.slice(6);
+      }
+      return digitsOnly.slice(0, 4) + "-" + digitsOnly.slice(4, 6) + "-" + digitsOnly.slice(6);
+    }
+  }
+  return digitsOnly;
+}
+
+// src/hooks/usePostalCodeField.ts
+function usePostalCodeField(options) {
+  const {
+    widthMode,
+    onInvalid,
+    autoHyphen = true,
+    normalizeOn = "blur",
+    validateOn = "blur",
+    errorMessages = {}
+  } = options;
+  const [value, setValue] = (0, import_react2.useState)("");
+  const [error, setError] = (0, import_react2.useState)(null);
+  const [isValidating, setIsValidating] = (0, import_react2.useState)(false);
+  const isComposingRef = (0, import_react2.useRef)(false);
+  const messages = {
+    invalidWidth: errorMessages.invalidWidth ?? defaultErrorMessages.invalidWidth,
+    invalidFormat: errorMessages.invalidFormat ?? defaultErrorMessages.invalidPostalCode
+  };
+  const normalizeWidth = (0, import_react2.useCallback)(
+    (val) => {
+      if (widthMode === "half-width-only") {
+        let normalized = toHalfWidthNumbers(val);
+        normalized = toHalfWidthHyphen(normalized);
+        return normalized;
+      } else {
+        let normalized = toFullWidthNumbers(val);
+        normalized = toFullWidthHyphen(normalized);
+        return normalized;
+      }
+    },
+    [widthMode]
+  );
+  const normalize = (0, import_react2.useCallback)(
+    (val) => {
+      let normalized = val;
+      if (onInvalid === "auto-convert") {
+        normalized = normalizeWidth(normalized);
+      }
+      if (autoHyphen && widthMode === "half-width-only") {
+        normalized = addPostalCodeHyphen(normalized);
+      }
+      return normalized;
+    },
+    [onInvalid, autoHyphen, widthMode, normalizeWidth]
+  );
+  const validate = (0, import_react2.useCallback)(
+    (val) => {
+      if (!val) return null;
+      if (onInvalid === "error") {
+        if (widthMode === "half-width-only" && !isHalfWidthPostalCode(val)) {
+          return messages.invalidWidth;
+        }
+        if (widthMode === "full-width-only" && !isFullWidthPostalCode(val)) {
+          return messages.invalidWidth;
+        }
+      }
+      if (!validatePostalCode(val)) {
+        return messages.invalidFormat;
+      }
+      return null;
+    },
+    [onInvalid, widthMode, messages.invalidWidth, messages.invalidFormat]
+  );
+  const handleChange = (0, import_react2.useCallback)(
+    (e) => {
+      const newValue = e.target.value;
+      setValue(newValue);
+      if (isComposingRef.current) return;
+      if (normalizeOn === "change") {
+        setValue(normalize(newValue));
+      }
+      if (validateOn === "change") {
+        setIsValidating(true);
+        const validationError = validate(
+          normalizeOn === "change" ? normalize(newValue) : newValue
+        );
+        setError(validationError);
+        setIsValidating(false);
+      }
+    },
+    [normalize, validate, normalizeOn, validateOn]
+  );
+  const handleBlur = (0, import_react2.useCallback)(
+    (e) => {
+      const currentValue = e.target.value;
+      if (normalizeOn === "blur") {
+        const normalized = normalize(currentValue);
+        setValue(normalized);
+        if (validateOn === "blur") {
+          setIsValidating(true);
+          setError(validate(normalized));
+          setIsValidating(false);
+        }
+      } else if (validateOn === "blur") {
+        setIsValidating(true);
+        setError(validate(currentValue));
+        setIsValidating(false);
+      }
+    },
+    [normalize, validate, normalizeOn, validateOn]
+  );
+  const handleCompositionStart = (0, import_react2.useCallback)(
+    (_e) => {
+      isComposingRef.current = true;
+    },
+    []
+  );
+  const handleCompositionEnd = (0, import_react2.useCallback)(
+    (e) => {
+      isComposingRef.current = false;
+      const currentValue = e.currentTarget.value;
+      if (normalizeOn === "compositionEnd") {
+        const normalized = normalize(currentValue);
+        setValue(normalized);
+        if (validateOn === "blur" || validateOn === "change") {
+          setIsValidating(true);
+          setError(validate(normalized));
+          setIsValidating(false);
+        }
+      }
+    },
+    [normalize, validate, normalizeOn, validateOn]
+  );
+  return {
+    value,
+    onChange: handleChange,
+    onBlur: handleBlur,
+    onCompositionStart: handleCompositionStart,
+    onCompositionEnd: handleCompositionEnd,
+    error,
+    isValidating,
+    isComposing: isComposingRef.current
+  };
+}
+
+// src/hooks/usePrefectureField.ts
+var import_react3 = require("react");
+
+// src/validators/prefecture.ts
+var PREFECTURES = [
+  "\u5317\u6D77\u9053",
+  "\u9752\u68EE\u770C",
+  "\u5CA9\u624B\u770C",
+  "\u5BAE\u57CE\u770C",
+  "\u79CB\u7530\u770C",
+  "\u5C71\u5F62\u770C",
+  "\u798F\u5CF6\u770C",
+  "\u8328\u57CE\u770C",
+  "\u6803\u6728\u770C",
+  "\u7FA4\u99AC\u770C",
+  "\u57FC\u7389\u770C",
+  "\u5343\u8449\u770C",
+  "\u6771\u4EAC\u90FD",
+  "\u795E\u5948\u5DDD\u770C",
+  "\u65B0\u6F5F\u770C",
+  "\u5BCC\u5C71\u770C",
+  "\u77F3\u5DDD\u770C",
+  "\u798F\u4E95\u770C",
+  "\u5C71\u68A8\u770C",
+  "\u9577\u91CE\u770C",
+  "\u5C90\u961C\u770C",
+  "\u9759\u5CA1\u770C",
+  "\u611B\u77E5\u770C",
+  "\u4E09\u91CD\u770C",
+  "\u6ECB\u8CC0\u770C",
+  "\u4EAC\u90FD\u5E9C",
+  "\u5927\u962A\u5E9C",
+  "\u5175\u5EAB\u770C",
+  "\u5948\u826F\u770C",
+  "\u548C\u6B4C\u5C71\u770C",
+  "\u9CE5\u53D6\u770C",
+  "\u5CF6\u6839\u770C",
+  "\u5CA1\u5C71\u770C",
+  "\u5E83\u5CF6\u770C",
+  "\u5C71\u53E3\u770C",
+  "\u5FB3\u5CF6\u770C",
+  "\u9999\u5DDD\u770C",
+  "\u611B\u5A9B\u770C",
+  "\u9AD8\u77E5\u770C",
+  "\u798F\u5CA1\u770C",
+  "\u4F50\u8CC0\u770C",
+  "\u9577\u5D0E\u770C",
+  "\u718A\u672C\u770C",
+  "\u5927\u5206\u770C",
+  "\u5BAE\u5D0E\u770C",
+  "\u9E7F\u5150\u5CF6\u770C",
+  "\u6C96\u7E04\u770C"
+];
+var PREFECTURE_SHORT_NAMES = {
+  \u5317\u6D77: "\u5317\u6D77\u9053",
+  \u9752\u68EE: "\u9752\u68EE\u770C",
+  \u5CA9\u624B: "\u5CA9\u624B\u770C",
+  \u5BAE\u57CE: "\u5BAE\u57CE\u770C",
+  \u79CB\u7530: "\u79CB\u7530\u770C",
+  \u5C71\u5F62: "\u5C71\u5F62\u770C",
+  \u798F\u5CF6: "\u798F\u5CF6\u770C",
+  \u8328\u57CE: "\u8328\u57CE\u770C",
+  \u6803\u6728: "\u6803\u6728\u770C",
+  \u7FA4\u99AC: "\u7FA4\u99AC\u770C",
+  \u57FC\u7389: "\u57FC\u7389\u770C",
+  \u5343\u8449: "\u5343\u8449\u770C",
+  \u6771\u4EAC: "\u6771\u4EAC\u90FD",
+  \u795E\u5948\u5DDD: "\u795E\u5948\u5DDD\u770C",
+  \u65B0\u6F5F: "\u65B0\u6F5F\u770C",
+  \u5BCC\u5C71: "\u5BCC\u5C71\u770C",
+  \u77F3\u5DDD: "\u77F3\u5DDD\u770C",
+  \u798F\u4E95: "\u798F\u4E95\u770C",
+  \u5C71\u68A8: "\u5C71\u68A8\u770C",
+  \u9577\u91CE: "\u9577\u91CE\u770C",
+  \u5C90\u961C: "\u5C90\u961C\u770C",
+  \u9759\u5CA1: "\u9759\u5CA1\u770C",
+  \u611B\u77E5: "\u611B\u77E5\u770C",
+  \u4E09\u91CD: "\u4E09\u91CD\u770C",
+  \u6ECB\u8CC0: "\u6ECB\u8CC0\u770C",
+  \u4EAC\u90FD: "\u4EAC\u90FD\u5E9C",
+  \u5927\u962A: "\u5927\u962A\u5E9C",
+  \u5175\u5EAB: "\u5175\u5EAB\u770C",
+  \u5948\u826F: "\u5948\u826F\u770C",
+  \u548C\u6B4C\u5C71: "\u548C\u6B4C\u5C71\u770C",
+  \u9CE5\u53D6: "\u9CE5\u53D6\u770C",
+  \u5CF6\u6839: "\u5CF6\u6839\u770C",
+  \u5CA1\u5C71: "\u5CA1\u5C71\u770C",
+  \u5E83\u5CF6: "\u5E83\u5CF6\u770C",
+  \u5C71\u53E3: "\u5C71\u53E3\u770C",
+  \u5FB3\u5CF6: "\u5FB3\u5CF6\u770C",
+  \u9999\u5DDD: "\u9999\u5DDD\u770C",
+  \u611B\u5A9B: "\u611B\u5A9B\u770C",
+  \u9AD8\u77E5: "\u9AD8\u77E5\u770C",
+  \u798F\u5CA1: "\u798F\u5CA1\u770C",
+  \u4F50\u8CC0: "\u4F50\u8CC0\u770C",
+  \u9577\u5D0E: "\u9577\u5D0E\u770C",
+  \u718A\u672C: "\u718A\u672C\u770C",
+  \u5927\u5206: "\u5927\u5206\u770C",
+  \u5BAE\u5D0E: "\u5BAE\u5D0E\u770C",
+  \u9E7F\u5150\u5CF6: "\u9E7F\u5150\u5CF6\u770C",
+  \u6C96\u7E04: "\u6C96\u7E04\u770C"
+};
+function validatePrefecture(value) {
+  if (!value) return true;
+  return PREFECTURES.includes(value) || Object.keys(PREFECTURE_SHORT_NAMES).includes(value);
+}
+function normalizePrefecture(value) {
+  if (!value) return value;
+  if (PREFECTURES.includes(value)) {
+    return value;
+  }
+  return PREFECTURE_SHORT_NAMES[value] || value;
+}
+
+// src/hooks/usePrefectureField.ts
+function usePrefectureField(options = {}) {
+  const {
+    autoComplete = true,
+    normalizeOn = "blur",
+    validateOn = "blur",
+    errorMessages = {}
+  } = options;
+  const [value, setValue] = (0, import_react3.useState)("");
+  const [error, setError] = (0, import_react3.useState)(null);
+  const [isValidating, setIsValidating] = (0, import_react3.useState)(false);
+  const isComposingRef = (0, import_react3.useRef)(false);
+  const messages = {
+    invalidPrefecture: errorMessages.invalidPrefecture ?? defaultErrorMessages.invalidPrefecture
+  };
+  const normalize = (0, import_react3.useCallback)(
+    (val) => {
+      if (autoComplete) {
+        return normalizePrefecture(val);
+      }
+      return val;
+    },
+    [autoComplete]
+  );
+  const validate = (0, import_react3.useCallback)(
+    (val) => {
+      if (!val) return null;
+      if (!validatePrefecture(val)) {
+        return messages.invalidPrefecture;
+      }
+      return null;
+    },
+    [messages.invalidPrefecture]
+  );
+  const handleChange = (0, import_react3.useCallback)(
+    (e) => {
+      const newValue = e.target.value;
+      setValue(newValue);
+      if (isComposingRef.current) return;
+      if (normalizeOn === "change") {
+        setValue(normalize(newValue));
+      }
+      if (validateOn === "change") {
+        setIsValidating(true);
+        const validationError = validate(
+          normalizeOn === "change" ? normalize(newValue) : newValue
+        );
+        setError(validationError);
+        setIsValidating(false);
+      }
+    },
+    [normalize, validate, normalizeOn, validateOn]
+  );
+  const handleBlur = (0, import_react3.useCallback)(
+    (e) => {
+      const currentValue = e.target.value;
+      if (normalizeOn === "blur") {
+        const normalized = normalize(currentValue);
+        setValue(normalized);
+        if (validateOn === "blur") {
+          setIsValidating(true);
+          setError(validate(normalized));
+          setIsValidating(false);
+        }
+      } else if (validateOn === "blur") {
+        setIsValidating(true);
+        setError(validate(currentValue));
+        setIsValidating(false);
+      }
+    },
+    [normalize, validate, normalizeOn, validateOn]
+  );
+  const handleCompositionStart = (0, import_react3.useCallback)(
+    (_e) => {
+      isComposingRef.current = true;
+    },
+    []
+  );
+  const handleCompositionEnd = (0, import_react3.useCallback)(
+    (e) => {
+      isComposingRef.current = false;
+      const currentValue = e.currentTarget.value;
+      if (normalizeOn === "compositionEnd") {
+        const normalized = normalize(currentValue);
+        setValue(normalized);
+        if (validateOn === "blur" || validateOn === "change") {
+          setIsValidating(true);
+          setError(validate(normalized));
+          setIsValidating(false);
+        }
+      }
+    },
+    [normalize, validate, normalizeOn, validateOn]
+  );
+  return {
+    value,
+    onChange: handleChange,
+    onBlur: handleBlur,
+    onCompositionStart: handleCompositionStart,
+    onCompositionEnd: handleCompositionEnd,
+    error,
+    isValidating,
+    isComposing: isComposingRef.current
+  };
+}
+
+// src/hooks/useAddressField.ts
+var import_react4 = require("react");
+function containsHalfWidthAlphanumeric(value) {
+  return /[A-Za-z0-9]/.test(value);
+}
+function useAddressField(options) {
+  const {
+    alphanumericMode,
+    onInvalid,
+    normalizeOn = "blur",
+    validateOn = "blur",
+    errorMessages = {}
+  } = options;
+  const [value, setValue] = (0, import_react4.useState)("");
+  const [error, setError] = (0, import_react4.useState)(null);
+  const [isValidating, setIsValidating] = (0, import_react4.useState)(false);
+  const isComposingRef = (0, import_react4.useRef)(false);
+  const messages = {
+    invalidWidth: errorMessages.invalidWidth ?? defaultErrorMessages.invalidWidth
+  };
+  const normalize = (0, import_react4.useCallback)(
+    (val) => {
+      if (alphanumericMode === "full-width-only" && onInvalid === "auto-convert") {
+        return toFullWidth(val);
+      }
+      return val;
+    },
+    [alphanumericMode, onInvalid]
+  );
+  const validate = (0, import_react4.useCallback)(
+    (val) => {
+      if (!val) return null;
+      if (alphanumericMode === "full-width-only" && onInvalid === "error" && containsHalfWidthAlphanumeric(val)) {
+        return messages.invalidWidth;
+      }
+      return null;
+    },
+    [alphanumericMode, onInvalid, messages.invalidWidth]
+  );
+  const handleChange = (0, import_react4.useCallback)(
+    (e) => {
+      const newValue = e.target.value;
+      setValue(newValue);
+      if (isComposingRef.current) return;
+      if (normalizeOn === "change") {
+        setValue(normalize(newValue));
+      }
+      if (validateOn === "change") {
+        setIsValidating(true);
+        const validationError = validate(
+          normalizeOn === "change" ? normalize(newValue) : newValue
+        );
+        setError(validationError);
+        setIsValidating(false);
+      }
+    },
+    [normalize, validate, normalizeOn, validateOn]
+  );
+  const handleBlur = (0, import_react4.useCallback)(
+    (e) => {
+      const currentValue = e.target.value;
+      if (normalizeOn === "blur") {
+        const normalized = normalize(currentValue);
+        setValue(normalized);
+        if (validateOn === "blur") {
+          setIsValidating(true);
+          setError(validate(normalized));
+          setIsValidating(false);
+        }
+      } else if (validateOn === "blur") {
+        setIsValidating(true);
+        setError(validate(currentValue));
+        setIsValidating(false);
+      }
+    },
+    [normalize, validate, normalizeOn, validateOn]
+  );
+  const handleCompositionStart = (0, import_react4.useCallback)(
+    (_e) => {
+      isComposingRef.current = true;
+    },
+    []
+  );
+  const handleCompositionEnd = (0, import_react4.useCallback)(
+    (e) => {
+      isComposingRef.current = false;
+      const currentValue = e.currentTarget.value;
+      if (normalizeOn === "compositionEnd") {
+        const normalized = normalize(currentValue);
+        setValue(normalized);
+        if (validateOn === "blur" || validateOn === "change") {
+          setIsValidating(true);
+          setError(validate(normalized));
+          setIsValidating(false);
+        }
+      }
+    },
+    [normalize, validate, normalizeOn, validateOn]
+  );
+  return {
+    value,
+    onChange: handleChange,
+    onBlur: handleBlur,
+    onCompositionStart: handleCompositionStart,
+    onCompositionEnd: handleCompositionEnd,
+    error,
+    isValidating,
+    isComposing: isComposingRef.current
+  };
+}
+
+// src/hooks/usePhoneNumberField.ts
+var import_react5 = require("react");
+
+// src/validators/phoneNumber.ts
+function validatePhoneNumber(value) {
+  if (!value) return true;
+  const normalized = value.replace(/[０-９]/g, (s) => String.fromCharCode(s.charCodeAt(0) - 65248)).replace(/[ー－]/g, "-");
+  const digitsOnly = normalized.replace(/-/g, "");
+  if (digitsOnly.length < 10 || digitsOnly.length > 11) {
+    return false;
+  }
+  const phoneRegex = /^[\d-]+$/;
+  return phoneRegex.test(normalized);
+}
+function isHalfWidthPhoneNumber(value) {
+  if (!value) return true;
+  const halfWidthRegex = /^[\d-]+$/;
+  return halfWidthRegex.test(value);
+}
+function containsFullWidthPhoneNumber(value) {
+  if (!value) return false;
+  const fullWidthRegex = /[０-９ー－]/;
+  return fullWidthRegex.test(value);
+}
+
+// src/hooks/usePhoneNumberField.ts
+function usePhoneNumberField(options) {
+  const {
+    onInvalid,
+    autoHyphen = true,
+    normalizeOn = "blur",
+    validateOn = "blur",
+    errorMessages = {}
+  } = options;
+  const [value, setValue] = (0, import_react5.useState)("");
+  const [error, setError] = (0, import_react5.useState)(null);
+  const [isValidating, setIsValidating] = (0, import_react5.useState)(false);
+  const isComposingRef = (0, import_react5.useRef)(false);
+  const messages = {
+    invalidWidth: errorMessages.invalidWidth ?? defaultErrorMessages.invalidWidth,
+    invalidFormat: errorMessages.invalidFormat ?? defaultErrorMessages.invalidPhoneNumber
+  };
+  const normalize = (0, import_react5.useCallback)(
+    (val) => {
+      let normalized = val;
+      if (onInvalid === "auto-convert") {
+        normalized = toHalfWidthNumbers(normalized);
+        normalized = toHalfWidthHyphen(normalized);
+      }
+      if (autoHyphen) {
+        normalized = addPhoneNumberHyphen(normalized);
+      }
+      return normalized;
+    },
+    [onInvalid, autoHyphen]
+  );
+  const validate = (0, import_react5.useCallback)(
+    (val) => {
+      if (!val) return null;
+      if (onInvalid === "error" && containsFullWidthPhoneNumber(val)) {
+        return messages.invalidWidth;
+      }
+      if (!validatePhoneNumber(val)) {
+        return messages.invalidFormat;
+      }
+      return null;
+    },
+    [onInvalid, messages.invalidWidth, messages.invalidFormat]
+  );
+  const handleChange = (0, import_react5.useCallback)(
+    (e) => {
+      const newValue = e.target.value;
+      setValue(newValue);
+      if (isComposingRef.current) return;
+      if (normalizeOn === "change") {
+        setValue(normalize(newValue));
+      }
+      if (validateOn === "change") {
+        setIsValidating(true);
+        const validationError = validate(
+          normalizeOn === "change" ? normalize(newValue) : newValue
+        );
+        setError(validationError);
+        setIsValidating(false);
+      }
+    },
+    [normalize, validate, normalizeOn, validateOn]
+  );
+  const handleBlur = (0, import_react5.useCallback)(
+    (e) => {
+      const currentValue = e.target.value;
+      if (normalizeOn === "blur") {
+        const normalized = normalize(currentValue);
+        setValue(normalized);
+        if (validateOn === "blur") {
+          setIsValidating(true);
+          setError(validate(normalized));
+          setIsValidating(false);
+        }
+      } else if (validateOn === "blur") {
+        setIsValidating(true);
+        setError(validate(currentValue));
+        setIsValidating(false);
+      }
+    },
+    [normalize, validate, normalizeOn, validateOn]
+  );
+  const handleCompositionStart = (0, import_react5.useCallback)(
+    (_e) => {
+      isComposingRef.current = true;
+    },
+    []
+  );
+  const handleCompositionEnd = (0, import_react5.useCallback)(
+    (e) => {
+      isComposingRef.current = false;
+      const currentValue = e.currentTarget.value;
+      if (normalizeOn === "compositionEnd") {
+        const normalized = normalize(currentValue);
+        setValue(normalized);
+        if (validateOn === "blur" || validateOn === "change") {
+          setIsValidating(true);
+          setError(validate(normalized));
+          setIsValidating(false);
+        }
+      }
+    },
+    [normalize, validate, normalizeOn, validateOn]
+  );
+  return {
+    value,
+    onChange: handleChange,
+    onBlur: handleBlur,
+    onCompositionStart: handleCompositionStart,
+    onCompositionEnd: handleCompositionEnd,
+    error,
+    isValidating,
+    isComposing: isComposingRef.current
+  };
+}
+
+// src/validators/hiragana.ts
+function validateHiragana(value) {
+  if (!value) return true;
+  const hiraganaRegex = /^[\u3040-\u309F\u30FC\u3000\s]+$/;
+  return hiraganaRegex.test(value);
+}
+function containsKatakana(value) {
+  if (!value) return false;
+  const katakanaRegex = /[\u30A0-\u30FF]/;
+  return katakanaRegex.test(value);
+}
+
+// src/normalizers/toHiragana.ts
+function toHiragana(value) {
+  if (!value) return value;
+  return value.replace(/[\u30A1-\u30F6]/g, (char) => {
+    return String.fromCharCode(char.charCodeAt(0) - 96);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PREFECTURES,
+  PREFECTURE_SHORT_NAMES,
+  addPhoneNumberHyphen,
+  addPostalCodeHyphen,
+  containsFullWidthPhoneNumber,
+  containsHiragana,
+  containsKatakana,
+  defaultErrorMessages,
+  isFullWidthPostalCode,
+  isHalfWidthPhoneNumber,
+  isHalfWidthPostalCode,
+  normalizePrefecture,
+  toFullWidth,
+  toFullWidthHyphen,
+  toFullWidthNumbers,
+  toHalfWidth,
+  toHalfWidthHyphen,
+  toHalfWidthNumbers,
+  toHiragana,
+  toKatakana,
+  useAddressField,
+  useNameField,
+  usePhoneNumberField,
+  usePostalCodeField,
+  usePrefectureField,
+  validateHiragana,
+  validateKatakana,
+  validatePhoneNumber,
+  validatePostalCode,
+  validatePrefecture
+});