@cp949/japanpost-react 1.0.2 → 1.0.4

package/dist/client.es.js

@@ -0,0 +1,495 @@
+"use client";
+import { useState, useMemo, useRef, useCallback, useEffect } from 'react';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+// src/components/AddressSearchInput.tsx
+function AddressSearchInput({
+  defaultValue = "",
+  value,
+  disabled,
+  label = "Address keyword",
+  buttonLabel = "Search",
+  inputProps,
+  buttonProps,
+  onChange,
+  onSearch
+}) {
+  const [internalValue, setInternalValue] = useState(defaultValue);
+  const currentValue = value ?? internalValue;
+  function handleSubmit(event) {
+    event.preventDefault();
+    onSearch(currentValue.trim());
+  }
+  function handleChange(nextValue) {
+    if (value === void 0) {
+      setInternalValue(nextValue);
+    }
+    onChange?.(nextValue);
+  }
+  return /* @__PURE__ */ jsxs("form", { onSubmit: handleSubmit, children: [
+    /* @__PURE__ */ jsxs("label", { children: [
+      label,
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          ...inputProps,
+          disabled,
+          value: currentValue,
+          onChange: (event) => handleChange(event.target.value)
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx("button", { ...buttonProps, disabled, type: "submit", children: buttonLabel })
+  ] });
+}
+
+// src/core/formatters.ts
+function normalizeJapanPostalCode(value) {
+  return value.replace(/[^\d]/g, "");
+}
+function PostalCodeInput({
+  defaultValue = "",
+  value,
+  disabled,
+  label = "Postal code",
+  buttonLabel = "Search",
+  inputProps,
+  buttonProps,
+  onChange,
+  onSearch
+}) {
+  const [internalValue, setInternalValue] = useState(defaultValue);
+  const currentValue = value ?? internalValue;
+  function handleSubmit(event) {
+    event.preventDefault();
+    onSearch(normalizeJapanPostalCode(currentValue));
+  }
+  function handleChange(nextValue) {
+    if (value === void 0) {
+      setInternalValue(nextValue);
+    }
+    onChange?.(nextValue);
+  }
+  return /* @__PURE__ */ jsxs("form", { onSubmit: handleSubmit, children: [
+    /* @__PURE__ */ jsxs("label", { children: [
+      label,
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          ...inputProps,
+          disabled,
+          inputMode: inputProps?.inputMode ?? "numeric",
+          value: currentValue,
+          onChange: (event) => handleChange(event.target.value)
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx("button", { ...buttonProps, disabled, type: "submit", children: buttonLabel })
+  ] });
+}
+
+// src/core/errors.ts
+function createJapanAddressError(code, message, options) {
+  const error = new Error(message);
+  error.name = "JapanAddressError";
+  error.code = code;
+  error.cause = options?.cause;
+  error.status = options?.status;
+  return error;
+}
+
+// src/react/toJapanAddressError.ts
+function toJapanAddressError(error) {
+  if (typeof error === "object" && error !== null && "code" in error && typeof error.code === "string") {
+    return error;
+  }
+  return createJapanAddressError(
+    "data_source_error",
+    error instanceof Error ? error.message : "Unknown error",
+    {
+      cause: error
+    }
+  );
+}
+function useLatestRequestState() {
+  const requestIdRef = useRef(0);
+  const isMountedRef = useRef(true);
+  const abortControllerRef = useRef(null);
+  const [loading, setLoading] = useState(false);
+  const [data, setData] = useState(null);
+  const [error, setError] = useState(null);
+  const isCurrentRequest = useCallback((requestId) => {
+    return isMountedRef.current && requestId === requestIdRef.current;
+  }, []);
+  const invalidateCurrentRequest = useCallback(() => {
+    requestIdRef.current += 1;
+    abortControllerRef.current?.abort();
+    abortControllerRef.current = null;
+  }, []);
+  useEffect(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+      invalidateCurrentRequest();
+    };
+  }, [invalidateCurrentRequest]);
+  const beginRequest = useCallback(() => {
+    const requestId = requestIdRef.current + 1;
+    requestIdRef.current = requestId;
+    abortControllerRef.current?.abort();
+    const abortController = new AbortController();
+    abortControllerRef.current = abortController;
+    setLoading(true);
+    setError(null);
+    return {
+      requestId,
+      signal: abortController.signal
+    };
+  }, []);
+  const setSuccess = useCallback((requestId, result) => {
+    if (isCurrentRequest(requestId)) {
+      setData(result);
+    }
+  }, [isCurrentRequest]);
+  const setFailure = useCallback(
+    (requestId, nextError) => {
+      if (isCurrentRequest(requestId)) {
+        setError(nextError);
+        setData(null);
+      }
+      return null;
+    },
+    [isCurrentRequest]
+  );
+  const cancel = useCallback(() => {
+    invalidateCurrentRequest();
+    setLoading(false);
+  }, [invalidateCurrentRequest]);
+  const finishRequest = useCallback((requestId) => {
+    if (isCurrentRequest(requestId)) {
+      setLoading(false);
+      abortControllerRef.current = null;
+    }
+  }, [isCurrentRequest]);
+  const reset = useCallback(() => {
+    cancel();
+    setData(null);
+    setError(null);
+  }, [cancel]);
+  return {
+    loading,
+    data,
+    error,
+    beginRequest,
+    setSuccess,
+    setFailure,
+    finishRequest,
+    cancel,
+    reset
+  };
+}
+
+// src/react/useJapanAddressSearch.ts
+function resolveAddressSearchDataSource(dataSource) {
+  if (dataSource) {
+    return dataSource;
+  }
+  throw new Error("useJapanAddressSearch requires options.dataSource");
+}
+function normalizeSearchText(value) {
+  const normalized = value?.trim();
+  return normalized ? normalized : void 0;
+}
+function normalizeAddressSearchInput(input) {
+  const request = typeof input === "string" ? { addressQuery: input } : input;
+  const addressQuery = normalizeSearchText(request.addressQuery);
+  const prefCode = normalizeSearchText(request.prefCode);
+  const prefName = normalizeSearchText(request.prefName);
+  const prefKana = normalizeSearchText(request.prefKana);
+  const prefRoma = normalizeSearchText(request.prefRoma);
+  const cityCode = normalizeSearchText(request.cityCode);
+  const cityName = normalizeSearchText(request.cityName);
+  const cityKana = normalizeSearchText(request.cityKana);
+  const cityRoma = normalizeSearchText(request.cityRoma);
+  const townName = normalizeSearchText(request.townName);
+  const townKana = normalizeSearchText(request.townKana);
+  const townRoma = normalizeSearchText(request.townRoma);
+  if (addressQuery === void 0 && prefCode === void 0 && prefName === void 0 && prefKana === void 0 && prefRoma === void 0 && cityCode === void 0 && cityName === void 0 && cityKana === void 0 && cityRoma === void 0 && townName === void 0 && townKana === void 0 && townRoma === void 0) {
+    return null;
+  }
+  return {
+    ...addressQuery === void 0 ? {} : { addressQuery },
+    ...prefCode === void 0 ? {} : { prefCode },
+    ...prefName === void 0 ? {} : { prefName },
+    ...prefKana === void 0 ? {} : { prefKana },
+    ...prefRoma === void 0 ? {} : { prefRoma },
+    ...cityCode === void 0 ? {} : { cityCode },
+    ...cityName === void 0 ? {} : { cityName },
+    ...cityKana === void 0 ? {} : { cityKana },
+    ...cityRoma === void 0 ? {} : { cityRoma },
+    ...townName === void 0 ? {} : { townName },
+    ...townKana === void 0 ? {} : { townKana },
+    ...townRoma === void 0 ? {} : { townRoma },
+    pageNumber: request.pageNumber ?? 0,
+    rowsPerPage: request.rowsPerPage ?? 100,
+    ...request.includeCityDetails === void 0 ? {} : {
+      includeCityDetails: request.includeCityDetails
+    },
+    ...request.includePrefectureDetails === void 0 ? {} : {
+      includePrefectureDetails: request.includePrefectureDetails
+    }
+  };
+}
+function waitForAbort(signal) {
+  if (signal.aborted) {
+    return Promise.resolve(null);
+  }
+  return new Promise((resolve) => {
+    const onAbort = () => {
+      signal.removeEventListener("abort", onAbort);
+      resolve(null);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function useJapanAddressSearch(options) {
+  const dataSource = useMemo(
+    () => resolveAddressSearchDataSource(options.dataSource),
+    [options.dataSource]
+  );
+  const debounceMs = options.debounceMs ?? 0;
+  const timeoutRef = useRef(
+    null
+  );
+  const pendingResolveRef = useRef(null);
+  const {
+    loading,
+    data,
+    error,
+    beginRequest,
+    setSuccess,
+    setFailure,
+    finishRequest,
+    cancel: cancelRequestState,
+    reset: resetRequestState
+  } = useLatestRequestState();
+  const clearPendingDebounce = useCallback(
+    (result) => {
+      if (timeoutRef.current !== null) {
+        globalThis.clearTimeout(timeoutRef.current);
+        timeoutRef.current = null;
+      }
+      pendingResolveRef.current?.(result);
+      pendingResolveRef.current = null;
+    },
+    []
+  );
+  useEffect(() => {
+    return () => {
+      clearPendingDebounce(null);
+    };
+  }, [clearPendingDebounce]);
+  const reset = useCallback(() => {
+    clearPendingDebounce(null);
+    resetRequestState();
+  }, [clearPendingDebounce, resetRequestState]);
+  const cancel = useCallback(() => {
+    clearPendingDebounce(null);
+    cancelRequestState();
+  }, [clearPendingDebounce, cancelRequestState]);
+  const runSearch = useCallback(async (requestId, signal, request) => {
+    try {
+      const requestOptions = {
+        signal
+      };
+      const searchPromise = dataSource.searchAddress(
+        request,
+        requestOptions
+      );
+      const result = await Promise.race([
+        searchPromise,
+        waitForAbort(signal)
+      ]);
+      if (signal.aborted || result === null) {
+        return null;
+      }
+      setSuccess(requestId, result);
+      return result;
+    } catch (caughtError) {
+      if (signal.aborted) {
+        return null;
+      }
+      return setFailure(requestId, toJapanAddressError(caughtError));
+    } finally {
+      finishRequest(requestId);
+    }
+  }, [dataSource, finishRequest, setFailure, setSuccess]);
+  const search = useCallback((input) => {
+    const request = normalizeAddressSearchInput(input);
+    const { requestId, signal } = beginRequest();
+    clearPendingDebounce(null);
+    if (request === null) {
+      const result = setFailure(
+        requestId,
+        createJapanAddressError(
+          "invalid_query",
+          "Address query is required"
+        )
+      );
+      finishRequest(requestId);
+      return Promise.resolve(result);
+    }
+    if (debounceMs <= 0) {
+      return new Promise((resolve) => {
+        pendingResolveRef.current = resolve;
+        void runSearch(requestId, signal, request).then((result) => {
+          resolve(result);
+          if (pendingResolveRef.current === resolve) {
+            pendingResolveRef.current = null;
+          }
+        });
+      });
+    }
+    return new Promise((resolve) => {
+      pendingResolveRef.current = resolve;
+      timeoutRef.current = globalThis.setTimeout(() => {
+        timeoutRef.current = null;
+        const pendingResolve = pendingResolveRef.current;
+        pendingResolveRef.current = null;
+        void runSearch(requestId, signal, request).then((result) => {
+          pendingResolve?.(result);
+        });
+      }, debounceMs);
+    });
+  }, [beginRequest, clearPendingDebounce, debounceMs, runSearch]);
+  return {
+    loading,
+    data,
+    error,
+    cancel,
+    reset,
+    search
+  };
+}
+function resolvePostalCodeDataSource(dataSource) {
+  if (dataSource) {
+    return dataSource;
+  }
+  throw new Error("useJapanPostalCode requires options.dataSource");
+}
+function useJapanPostalCode(options) {
+  const dataSource = useMemo(
+    () => resolvePostalCodeDataSource(options.dataSource),
+    [options.dataSource]
+  );
+  const {
+    loading,
+    data,
+    error,
+    beginRequest,
+    setSuccess,
+    setFailure,
+    finishRequest,
+    cancel,
+    reset
+  } = useLatestRequestState();
+  const search = useCallback(
+    async (input) => {
+      const { requestId, signal } = beginRequest();
+      try {
+        const requestInput = typeof input === "string" ? { postalCode: input } : input;
+        const postalCode = normalizeJapanPostalCode(requestInput.postalCode);
+        if (!/^\d{3,7}$/.test(postalCode)) {
+          throw createJapanAddressError(
+            "invalid_postal_code",
+            "Postal code must contain between 3 and 7 digits"
+          );
+        }
+        const requestOptions = {
+          signal
+        };
+        const request = {
+          postalCode,
+          pageNumber: requestInput.pageNumber ?? 0,
+          rowsPerPage: requestInput.rowsPerPage ?? 100,
+          ...requestInput.includeParenthesesTown === void 0 ? {} : {
+            includeParenthesesTown: requestInput.includeParenthesesTown
+          }
+        };
+        const result = await dataSource.lookupPostalCode(
+          request,
+          requestOptions
+        );
+        if (signal.aborted) {
+          return null;
+        }
+        setSuccess(requestId, result);
+        return result;
+      } catch (caughtError) {
+        if (signal.aborted) {
+          return null;
+        }
+        return setFailure(requestId, toJapanAddressError(caughtError));
+      } finally {
+        finishRequest(requestId);
+      }
+    },
+    [beginRequest, dataSource, finishRequest, setFailure, setSuccess]
+  );
+  return {
+    loading,
+    data,
+    error,
+    cancel,
+    reset,
+    search
+  };
+}
+
+// src/react/useJapanAddress.ts
+function useJapanAddress(options) {
+  const dataSource = useMemo(() => {
+    if (options.dataSource) {
+      return options.dataSource;
+    }
+    throw new Error("useJapanAddress requires options.dataSource");
+  }, [options.dataSource]);
+  const postalCode = useJapanPostalCode({ dataSource });
+  const addressSearch = useJapanAddressSearch({
+    dataSource,
+    debounceMs: options.debounceMs
+  });
+  const resetPostalCode = postalCode.reset;
+  const searchPostalCode = postalCode.search;
+  const resetAddressSearch = addressSearch.reset;
+  const searchAddressKeyword = addressSearch.search;
+  const [activeSearch, setActiveSearch] = useState(null);
+  const searchByPostalCode = useCallback(async (input) => {
+    resetAddressSearch();
+    setActiveSearch("postalCode");
+    return searchPostalCode(input);
+  }, [resetAddressSearch, searchPostalCode]);
+  const searchByAddressQuery = useCallback(async (input) => {
+    resetPostalCode();
+    setActiveSearch("addressQuery");
+    return searchAddressKeyword(input);
+  }, [resetPostalCode, searchAddressKeyword]);
+  const reset = useCallback(() => {
+    resetPostalCode();
+    resetAddressSearch();
+    setActiveSearch(null);
+  }, [resetAddressSearch, resetPostalCode]);
+  const data = activeSearch === "postalCode" ? postalCode.data : activeSearch === "addressQuery" ? addressSearch.data : null;
+  const error = activeSearch === "postalCode" ? postalCode.error : activeSearch === "addressQuery" ? addressSearch.error : null;
+  return {
+    // 사용자는 현재 활성 모드만 보더라도, 내부에서는 두 훅 중 하나라도 정리 중이면 로딩으로 본다.
+    loading: postalCode.loading || addressSearch.loading,
+    data,
+    error,
+    reset,
+    searchByPostalCode,
+    searchByAddressQuery
+  };
+}
+
+export { AddressSearchInput, PostalCodeInput, useJapanAddress, useJapanAddressSearch, useJapanPostalCode };