@akanjs/next 0.0.39 → 0.0.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/next",
-  "version": "0.0.39",
+  "version": "0.0.40",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"
@@ -14,38 +14,5 @@
   "engines": {
     "node": ">=22"
   },
-  "dependencies": {
-    "@capacitor-community/contacts": "^6.1.1",
-    "@capacitor-community/fcm": "^7.1.1",
-    "@capacitor/app": "^7.0.1",
-    "@capacitor/camera": "^7.0.1",
-    "@capacitor/core": "^7.2.0",
-    "@capacitor/device": "^7.0.1",
-    "@capacitor/geolocation": "^7.1.2",
-    "@capacitor/haptics": "^7.0.1",
-    "@capacitor/keyboard": "^7.0.1",
-    "@capacitor/preferences": "^7.0.1",
-    "@capacitor/push-notifications": "^7.0.1",
-    "@capgo/capacitor-updater": "^7.0.50",
-    "@formatjs/intl-localematcher": "^0.5.10",
-    "@react-spring/web": "^9.7.5",
-    "@urql/core": "^5.1.0",
-    "@use-gesture/react": "^10.3.1",
-    "axios": "^1.7.9",
-    "capacitor-plugin-safe-area": "^3.0.4",
-    "clsx": "^2.1.1",
-    "cordova-plugin-purchase": "^13.12.1",
-    "dayjs": "^1.11.13",
-    "immer": "^10.1.1",
-    "js-cookie": "^3.0.5",
-    "jwt-decode": "^4.0.0",
-    "negotiator": "^1.0.0",
-    "next": "^15.3.2",
-    "pluralize": "^8.0.0",
-    "react": "^18.3.1",
-    "react-device-detect": "^2.2.3",
-    "react-dom": "^18.3.1",
-    "reflect-metadata": "^0.2.2",
-    "socket.io-client": "^4.8.1"
-  }
+  "dependencies": {}
 }

package/src/bootCsr.d.ts

@@ -0,0 +1,3 @@
+declare const bootCsr: (context: Record<string, () => Promise<unknown>>, rootPath: string, entryPath?: string) => Promise<void>;
+
+export { bootCsr };

package/src/bootCsr.js

@@ -0,0 +1,206 @@
+"use client";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bootCsr_exports = {};
+__export(bootCsr_exports, {
+  bootCsr: () => bootCsr
+});
+module.exports = __toCommonJS(bootCsr_exports);
+var import_client = require("@akanjs/client");
+var import_client2 = require("@akanjs/client");
+var import_common = require("@akanjs/common");
+var import_react = __toESM(require("react"));
+var ReactDOM = __toESM(require("react-dom/client"));
+var import_useCsrValues = require("./useCsrValues");
+const supportLanguages = [
+  "en",
+  "ko"
+];
+const bootCsr = /* @__PURE__ */ __name(async (context, rootPath, entryPath = "/route") => {
+  const [, jwt] = await Promise.all([
+    import_client.device.init({
+      supportLanguages
+    }),
+    import_client.storage.getItem("jwt")
+  ]);
+  if (jwt) (0, import_client.initAuth)({
+    jwt
+  });
+  import_common.Logger.verbose(`Set default language: ${import_client.device.lang}`);
+  const pages = {};
+  await Promise.all(Object.entries(context).map(async ([key, value]) => {
+    pages[key] = await value();
+  }));
+  const getPageState = /* @__PURE__ */ __name((csrConfig) => {
+    const { transition, safeArea, topInset, bottomInset, gesture, cache } = csrConfig ?? {};
+    const pageState = {
+      transition: transition ?? "none",
+      topSafeArea: safeArea === false ? 0 : import_client.device.topSafeArea,
+      bottomSafeArea: safeArea === false ? 0 : import_client.device.bottomSafeArea,
+      // topSafeArea: safeArea === false || device.info.platform === "android" ? 0 : device.topSafeArea,
+      // bottomSafeArea: safeArea === false || device.info.platform === "android" ? 0 : device.bottomSafeArea,
+      topInset: topInset === true ? import_client2.DEFAULT_TOP_INSET : topInset === false ? 0 : topInset ?? 0,
+      bottomInset: bottomInset === true ? import_client2.DEFAULT_BOTTOM_INSET : bottomInset === false ? 0 : bottomInset ?? 0,
+      gesture: gesture ?? true,
+      cache: cache ?? false
+    };
+    return pageState;
+  }, "getPageState");
+  const routeMap = /* @__PURE__ */ new Map();
+  routeMap.set("/", {
+    path: "/",
+    children: /* @__PURE__ */ new Map()
+  });
+  for (const filePath of Object.keys(pages)) {
+    const fileName = /\.\/(.*)\.tsx$/.exec(filePath)?.[1];
+    if (!fileName) continue;
+    const fileType = fileName.endsWith("page") ? "page" : fileName.endsWith("layout") ? "layout" : null;
+    if (!fileType) continue;
+    const pathSegments = [
+      "/",
+      ...fileName.split("/").slice(0, -1).map((segment) => `/${segment.replace(/\[(.*?)\]/g, ":$1")}`)
+    ];
+    const targetRouteMap = pathSegments.slice(0, -1).reduce((rMap, path) => {
+      if (!rMap.has(path)) rMap.set(path, {
+        path,
+        children: /* @__PURE__ */ new Map()
+      });
+      return rMap.get(path)?.children;
+    }, routeMap);
+    if (!targetRouteMap) continue;
+    const targetPath = pathSegments[pathSegments.length - 1];
+    targetRouteMap.set(targetPath, {
+      // action: pages[path]?.action,
+      // ErrorBoundary: pages[path]?.ErrorBoundary,
+      ...targetRouteMap.get(targetPath) ?? {
+        path: targetPath,
+        children: /* @__PURE__ */ new Map()
+      },
+      ...fileType === "layout" ? {
+        Layout: pages[filePath].default
+      } : {
+        Page: pages[filePath].default,
+        pageState: getPageState(pages[filePath].default.csrConfig),
+        csrConfig: pages[filePath].default.csrConfig
+      }
+    });
+  }
+  const pathname = window.location.pathname;
+  const initialPath = import_client.device.lang + entryPath;
+  window.document.body.style.overflow = "hidden";
+  const getPathRoutes = /* @__PURE__ */ __name((route, parentRootLayouts = [], parentLayouts = [], parentPaths = []) => {
+    const parentPath = parentPaths.filter((path2) => path2 !== "/").join("");
+    const currentPathSegment = /^\/\(.*\)$/.test(route.path) ? "" : route.path;
+    const isRoot = [
+      "/",
+      "/:lang"
+    ].includes(parentPath + currentPathSegment) && parentRootLayouts.length < 2;
+    const path = parentPath + currentPathSegment;
+    const pathSegments = [
+      ...parentPaths,
+      ...currentPathSegment ? [
+        currentPathSegment
+      ] : []
+    ];
+    const RootLayouts = [
+      ...parentRootLayouts,
+      ...isRoot && route.Layout ? [
+        route.Layout
+      ] : []
+    ];
+    const Layouts = [
+      ...parentLayouts,
+      ...!isRoot && route.Layout ? [
+        route.Layout
+      ] : []
+    ];
+    return [
+      ...route.Page ? [
+        {
+          path,
+          pathSegments,
+          Page: route.Page,
+          RootLayouts,
+          Layouts,
+          pageState: route.pageState ?? import_client2.defaultPageState
+        }
+      ] : [],
+      ...route.children.size ? [
+        ...route.children.values()
+      ].flatMap((child) => getPathRoutes(child, RootLayouts, Layouts, pathSegments)) : []
+    ];
+  }, "getPathRoutes");
+  const rootRoute = routeMap.get("/");
+  if (!rootRoute) throw new Error("No root route");
+  const pathRoutes = getPathRoutes(rootRoute);
+  const routeGuide = {
+    pathSegment: "/",
+    children: {}
+  };
+  pathRoutes.forEach((pathRoute) => {
+    const pathSegments = pathRoute.pathSegments.slice(1);
+    pathSegments.reduce((routeGuide2, pathSegment, index) => {
+      const child = routeGuide2.children[pathSegment];
+      routeGuide2.children[pathSegment] = {
+        ...child ?? {},
+        pathSegment,
+        ...index === pathSegments.length - 1 ? {
+          pathRoute
+        } : {},
+        children: child?.children ?? {}
+      };
+      return routeGuide2.children[pathSegment];
+    }, routeGuide);
+  });
+  const RouterProvider = /* @__PURE__ */ __name(() => {
+    const csrValues = (0, import_useCsrValues.useCsrValues)(routeGuide, pathRoutes);
+    const { location } = csrValues;
+    return /* @__PURE__ */ import_react.default.createElement(import_client2.csrContext.Provider, {
+      value: csrValues
+    }, location.pathRoute.RootLayouts.reduceRight((children, Layout) => {
+      return /* @__PURE__ */ import_react.default.createElement(Layout, {
+        params: location.params,
+        searchParams: location.searchParams
+      }, children);
+    }, /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null)));
+  }, "RouterProvider");
+  if (pathname !== `/${initialPath}`) {
+    window.location.replace(initialPath);
+    return;
+  } else {
+    const el = document.getElementById("root");
+    if (!el) throw new Error("No root element");
+    const root = ReactDOM.createRoot(el);
+    root.render(/* @__PURE__ */ import_react.default.createElement(RouterProvider, null));
+  }
+}, "bootCsr");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bootCsr
+});

package/src/createNextMiddleware.d.ts

@@ -0,0 +1,5 @@
+import { NextRequest, NextResponse } from 'next/server';
+
+declare const createNextMiddleware: () => (request: NextRequest) => NextResponse<unknown>;
+
+export { createNextMiddleware };

package/src/createNextMiddleware.js

@@ -0,0 +1,88 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createNextMiddleware_exports = {};
+__export(createNextMiddleware_exports, {
+  createNextMiddleware: () => createNextMiddleware
+});
+module.exports = __toCommonJS(createNextMiddleware_exports);
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import_intl_localematcher = require("@formatjs/intl-localematcher");
+var import_negotiator = __toESM(require("negotiator"));
+var import_server = require("next/server");
+const i18n = {
+  defaultLocale: "en",
+  locales: [
+    "en",
+    "ko"
+  ]
+};
+const basePaths = process.env.basePaths ? process.env.basePaths.split(",") : [];
+function getLocale(request) {
+  if (!request.headers.get("accept-language")) return i18n.defaultLocale;
+  const negotiatorHeaders = {};
+  request.headers.forEach((value, key) => negotiatorHeaders[key] = value);
+  try {
+    const languages = new import_negotiator.default({
+      headers: negotiatorHeaders
+    }).languages();
+    return (0, import_intl_localematcher.match)(languages, i18n.locales, i18n.defaultLocale);
+  } catch (e) {
+    return i18n.defaultLocale;
+  }
+}
+__name(getLocale, "getLocale");
+const createNextMiddleware = /* @__PURE__ */ __name(() => {
+  import_common.Logger.rawLog(import_base.logo, "console");
+  const middleware = /* @__PURE__ */ __name((request) => {
+    const pathname = request.nextUrl.pathname;
+    const pathnameIsMissingLocale = i18n.locales.every((locale2) => !pathname.startsWith(`/${locale2}/`) && pathname !== `/${locale2}`);
+    if (pathnameIsMissingLocale) return import_server.NextResponse.redirect(new URL(`/${getLocale(request)}/${request.nextUrl.href.split("/").slice(3).join("/")}`, request.url));
+    const splits = pathname.split("/");
+    const locale = splits[1];
+    const basePath = basePaths.includes(splits[2]) ? splits[2] : null;
+    const headers = new Headers(request.headers);
+    const searchParams = new URLSearchParams(request.nextUrl.search);
+    const searchParamJwt = searchParams.get("jwt");
+    headers.set("x-locale", locale);
+    headers.set("x-path", "/" + splits.slice(2).join("/"));
+    if (basePath) headers.set("x-base-path", basePath);
+    if (searchParamJwt) headers.set("jwt", searchParamJwt);
+    return import_server.NextResponse.next({
+      request: {
+        headers
+      }
+    });
+  }, "middleware");
+  return middleware;
+}, "createNextMiddleware");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createNextMiddleware
+});

package/src/createRobotPage.d.ts

@@ -0,0 +1,5 @@
+import { MetadataRoute } from 'next';
+
+declare const createRobotPage: (clientHttpUri: string, config?: MetadataRoute.Robots) => MetadataRoute.Robots;
+
+export { createRobotPage };

package/src/createRobotPage.js

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+var createRobotPage_exports = {};
+__export(createRobotPage_exports, {
+  createRobotPage: () => createRobotPage
+});
+module.exports = __toCommonJS(createRobotPage_exports);
+const createRobotPage = /* @__PURE__ */ __name((clientHttpUri, config) => {
+  return {
+    ...config ?? {},
+    rules: {
+      userAgent: "*",
+      allow: "/",
+      disallow: "/admin/",
+      ...config?.rules ?? {}
+    },
+    sitemap: `${clientHttpUri}/sitemap.xml`
+  };
+}, "createRobotPage");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRobotPage
+});

package/src/createSitemapPage.d.ts

@@ -0,0 +1,5 @@
+import { MetadataRoute } from 'next';
+
+declare const createSitemapPage: (clientHttpUri: string, paths: string[]) => MetadataRoute.Sitemap;
+
+export { createSitemapPage };

package/src/createSitemapPage.js

@@ -0,0 +1,34 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+var createSitemapPage_exports = {};
+__export(createSitemapPage_exports, {
+  createSitemapPage: () => createSitemapPage
+});
+module.exports = __toCommonJS(createSitemapPage_exports);
+const lastModified = /* @__PURE__ */ new Date();
+const createSitemapPage = /* @__PURE__ */ __name((clientHttpUri, paths) => {
+  return paths.map((path) => ({
+    url: `${clientHttpUri}${path}`,
+    lastModified
+  }));
+}, "createSitemapPage");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSitemapPage
+});

package/src/index.d.ts

@@ -0,0 +1,33 @@
+export { LoginAuth, LoginForm } from './types.js';
+export { useFetch } from './useFetch.js';
+export { lazy } from './lazy.js';
+export { makePageProto } from './makePageProto.js';
+export { useDebounce } from './useDebounce.js';
+export { useInterval } from './useInterval.js';
+export { bootCsr } from './bootCsr.js';
+export { useCamera } from './useCamera.js';
+export { useContact } from './useContact.js';
+export { usePushNoti } from './usePushNoti.js';
+export { useGeoLocation } from './useGeoLocation.js';
+export { useCodepush } from './useCodepush.js';
+export { CdvProductType, PlatformType, ProductType, usePurchase } from './usePurchase.js';
+export { useCsrValues } from './useCsrValues.js';
+export { createRobotPage } from './createRobotPage.js';
+export { createSitemapPage } from './createSitemapPage.js';
+export { createNextMiddleware } from './createNextMiddleware.js';
+export { useThrottle } from './useThrottle.js';
+export { useHistory } from './useHistory.js';
+export { useLocation } from './useLocation.js';
+import 'next/dynamic';
+import 'react';
+import '@capacitor/camera';
+import '@capacitor-community/contacts';
+import '@capacitor/geolocation';
+import '@capacitor/core';
+import 'dayjs';
+import '@react-spring/web';
+import '@use-gesture/react/dist/declarations/src/types';
+import '../csrTypes-B6ATv9-y.js';
+import 'react-spring';
+import 'next';
+import 'next/server';

package/src/index.js

@@ -0,0 +1,82 @@
+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);
+var src_exports = {};
+__export(src_exports, {
+  bootCsr: () => import_bootCsr.bootCsr,
+  createNextMiddleware: () => import_createNextMiddleware.createNextMiddleware,
+  createRobotPage: () => import_createRobotPage.createRobotPage,
+  createSitemapPage: () => import_createSitemapPage.createSitemapPage,
+  lazy: () => import_lazy.lazy,
+  makePageProto: () => import_makePageProto.makePageProto,
+  useCamera: () => import_useCamera.useCamera,
+  useCodepush: () => import_useCodepush.useCodepush,
+  useContact: () => import_useContact.useContact,
+  useCsrValues: () => import_useCsrValues.useCsrValues,
+  useDebounce: () => import_useDebounce.useDebounce,
+  useFetch: () => import_useFetch.useFetch,
+  useGeoLocation: () => import_useGeoLocation.useGeoLocation,
+  useHistory: () => import_useHistory.useHistory,
+  useInterval: () => import_useInterval.useInterval,
+  useLocation: () => import_useLocation.useLocation,
+  usePurchase: () => import_usePurchase.usePurchase,
+  usePushNoti: () => import_usePushNoti.usePushNoti,
+  useThrottle: () => import_useThrottle.useThrottle
+});
+module.exports = __toCommonJS(src_exports);
+var import_useFetch = require("./useFetch");
+var import_lazy = require("./lazy");
+var import_makePageProto = require("./makePageProto");
+var import_useDebounce = require("./useDebounce");
+var import_useInterval = require("./useInterval");
+var import_bootCsr = require("./bootCsr");
+var import_useCamera = require("./useCamera");
+var import_useContact = require("./useContact");
+var import_usePushNoti = require("./usePushNoti");
+var import_useGeoLocation = require("./useGeoLocation");
+var import_useCodepush = require("./useCodepush");
+var import_usePurchase = require("./usePurchase");
+var import_useCsrValues = require("./useCsrValues");
+var import_createRobotPage = require("./createRobotPage");
+var import_createSitemapPage = require("./createSitemapPage");
+var import_createNextMiddleware = require("./createNextMiddleware");
+var import_useThrottle = require("./useThrottle");
+var import_useHistory = require("./useHistory");
+var import_useLocation = require("./useLocation");
+//! PageAgent csr에서 말썽 일으킨다
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bootCsr,
+  createNextMiddleware,
+  createRobotPage,
+  createSitemapPage,
+  lazy,
+  makePageProto,
+  useCamera,
+  useCodepush,
+  useContact,
+  useCsrValues,
+  useDebounce,
+  useFetch,
+  useGeoLocation,
+  useHistory,
+  useInterval,
+  useLocation,
+  usePurchase,
+  usePushNoti,
+  useThrottle
+});

package/src/lazy.d.ts

@@ -0,0 +1,8 @@
+import { DynamicOptions } from 'next/dynamic';
+import { ComponentType } from 'react';
+
+declare const lazy: <T extends ComponentType<any>>(loader: (x?: string) => Promise<{
+    default: T;
+} | T>, option?: DynamicOptions<T>) => T;
+
+export { lazy };

package/src/lazy.js

@@ -0,0 +1,40 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lazy_exports = {};
+__export(lazy_exports, {
+  lazy: () => lazy
+});
+module.exports = __toCommonJS(lazy_exports);
+var import_dynamic = __toESM(require("next/dynamic"));
+//! next build를 위해서 lint 무시
+const lazy = /* @__PURE__ */ __name((loader, option) => (0, import_dynamic.default)(loader, option ?? {}), "lazy");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  lazy
+});

package/src/makePageProto.d.ts

@@ -0,0 +1,42 @@
+import { ReactNode } from 'react';
+
+type TranslationSingle = readonly [string, string] | readonly [string, string, string, string];
+type TranslationWithParam = readonly [string, string, {
+    [key: string]: string | number;
+}];
+type Translation = TranslationSingle | TranslationWithParam;
+type GetKeys<O> = O extends infer U ? (U extends object ? keyof U : never) : never;
+type TransMessage<Locale extends Record<string, any>> = Locale extends infer U ? U extends object ? {
+    [K in keyof U]-?: `${K & string}${U[K] extends Record<string, any> ? `.${GetKeys<U[K]>}` : never}`;
+}[keyof U] : never : never;
+
+declare const makePageProto: <Locale extends {
+    [key: string]: {
+        [key: string]: Translation;
+    };
+}>(locales: Locale[]) => () => {
+    path: string;
+    l: {
+        (key: TransMessage<Locale>, param?: {
+            [key: string]: string | number;
+        }): string;
+        rich(key: TransMessage<Locale>, param?: {
+            [key: string]: string | number;
+        }): ReactNode;
+        field<ModelKey extends keyof Locale>(model: ModelKey, field: keyof Locale[ModelKey]): string;
+        desc<ModelKey extends keyof Locale>(model: ModelKey, field: keyof Locale[ModelKey]): string;
+        enum<ModelKey extends keyof Locale>(model: ModelKey, field: keyof Locale[ModelKey], value: string): string;
+        enumdesc<ModelKey extends keyof Locale>(model: ModelKey, field: keyof Locale[ModelKey], value: string): string;
+        api<ModelKey extends keyof Locale>(model: ModelKey, endpoint: keyof Locale[ModelKey]): string;
+        apidesc<ModelKey extends keyof Locale>(model: ModelKey, endpoint: keyof Locale[ModelKey]): string;
+        arg<ModelKey extends keyof Locale>(model: ModelKey, endpoint: keyof Locale[ModelKey], arg: string): string;
+        argdesc<ModelKey extends keyof Locale>(model: ModelKey, endpoint: keyof Locale[ModelKey], arg: string): string;
+        qry<ModelKey extends keyof Locale>(model: ModelKey, queryKey: keyof Locale[ModelKey]): string;
+        qrydesc<ModelKey extends keyof Locale>(model: ModelKey, queryKey: keyof Locale[ModelKey]): string;
+        qarg<ModelKey extends keyof Locale>(model: ModelKey, queryKey: keyof Locale[ModelKey], arg: string): string;
+        qargdesc<ModelKey extends keyof Locale>(model: ModelKey, queryKey: keyof Locale[ModelKey], arg: string): string;
+    };
+    lang: string;
+};
+
+export { makePageProto };