@akanjs/client 0.0.54 → 0.0.55

package/index.cjs

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var client_exports = {};
+module.exports = __toCommonJS(client_exports);
+__reExport(client_exports, require("./src"), module.exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/client",
-  "version": "0.0.54",
+  "version": "0.0.55",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -15,6 +15,23 @@
     "node": ">=22"
   },
   "dependencies": {
-    "next": "^15.3.2"
+    "@capacitor/core": "^7.2.0",
+    "@capacitor/device": "^7.0.1",
+    "@capacitor/haptics": "^7.0.1",
+    "@capacitor/keyboard": "^7.0.1",
+    "@capacitor/preferences": "^7.0.1",
+    "capacitor-plugin-safe-area": "^3.0.4",
+    "clsx": "^2.1.1",
+    "js-cookie": "^3.0.5",
+    "jwt-decode": "^4.0.0",
+    "next": "^15.3.2",
+    "react": "^18.3.1",
+    "react-device-detect": "^2.2.3"
+  },
+  "exports": {
+    ".": {
+      "require": "./index.cjs",
+      "import": "./index.js"
+    }
   }
 }

package/src/cookie.cjs

@@ -0,0 +1,142 @@
+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 __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 cookie_exports = {};
+__export(cookie_exports, {
+  cookies: () => cookies,
+  getAccount: () => getAccount,
+  getCookie: () => getCookie,
+  getHeader: () => getHeader,
+  getMe: () => getMe,
+  getSelf: () => getSelf,
+  headers: () => headers,
+  initAuth: () => initAuth,
+  removeCookie: () => removeCookie,
+  resetAuth: () => resetAuth,
+  setAuth: () => setAuth,
+  setCookie: () => setCookie
+});
+module.exports = __toCommonJS(cookie_exports);
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import_signal = require("@akanjs/signal");
+var import_signal2 = require("@akanjs/signal");
+var import_core = require("@capacitor/core");
+var import_js_cookie = __toESM(require("js-cookie"), 1);
+var import_jwt_decode = require("jwt-decode");
+var import_react = __toESM(require("react"), 1);
+var import_router = require("./router");
+var import_storage = require("./storage");
+const cookies = import_base.baseClientEnv.side === "server" ? () => {
+  const nextHeaders = require("next/headers");
+  const cookies2 = nextHeaders.cookies();
+  return import_react.default.use(cookies2);
+} : () => {
+  const cookie = import_js_cookie.default.get();
+  return new Map(
+    Object.entries(cookie).map(([key, value]) => [
+      key,
+      {
+        name: key,
+        value: typeof value === "string" && value.startsWith("j:") ? JSON.parse(value.slice(2)) : value
+      }
+    ])
+  );
+};
+const setCookie = (key, value, options = { path: "/", sameSite: "none", secure: true }) => {
+  if (import_base.baseClientEnv.side === "server")
+    return;
+  else
+    void import_core.CapacitorCookies.setCookie({ key, value });
+};
+const getCookie = (key) => {
+  if (import_base.baseClientEnv.side === "server")
+    return cookies().get(key)?.value;
+  else
+    return document.cookie.split(";").find((c) => c.trim().startsWith(`${key}=`))?.split("=")[1];
+};
+const removeCookie = (key, options = { path: "/" }) => {
+  if (import_base.baseClientEnv.side === "server")
+    return cookies().delete(key);
+  else {
+    document.cookie = `${key}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;`;
+  }
+};
+const headers = import_base.baseClientEnv.side === "server" ? () => import_react.default.use(require("next/headers").headers()) : () => /* @__PURE__ */ new Map();
+const getHeader = (key) => {
+  return headers().get(key);
+};
+const getAccount = () => {
+  const jwt = getCookie("jwt") ?? getHeader("jwt");
+  if (!jwt)
+    return import_signal2.defaultAccount;
+  const account = (0, import_jwt_decode.jwtDecode)(jwt);
+  if (account.appName !== import_base.baseEnv.appName || account.environment !== import_base.baseEnv.environment)
+    return import_signal2.defaultAccount;
+  return account;
+};
+function getMe(option) {
+  const me = getAccount().me;
+  if (!me && option) {
+    if (option.unauthorize === "notFound")
+      import_router.router.notFound();
+    else if (import_base.baseClientEnv.side === "client")
+      import_router.router.replace(option.unauthorize);
+    else
+      import_react.default.use(import_router.router.redirect(option.unauthorize));
+  }
+  return me;
+}
+function getSelf(option) {
+  const self = getAccount().self;
+  if (!self && option) {
+    if (option.unauthorize === "notFound")
+      import_router.router.notFound();
+    else if (import_base.baseClientEnv.side === "client")
+      import_router.router.replace(option.unauthorize);
+    else
+      import_react.default.use(import_router.router.redirect(option.unauthorize));
+  }
+  return self;
+}
+const setAuth = ({ jwt }) => {
+  import_signal.client.setJwt(jwt);
+  setCookie("jwt", jwt);
+  void import_storage.storage.setItem("jwt", jwt);
+};
+const initAuth = ({ jwt } = {}) => {
+  const token = jwt ?? cookies().get("jwt")?.value;
+  if (token)
+    setAuth({ jwt: token });
+  import_signal.client.init();
+  import_common.Logger.verbose(`JWT set from cookie: ${token}`);
+};
+const resetAuth = () => {
+  import_signal.client.reset();
+  removeCookie("jwt");
+  void import_storage.storage.removeItem("jwt");
+};

package/src/createFont.cjs

@@ -0,0 +1,29 @@
+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 createFont_exports = {};
+__export(createFont_exports, {
+  Nanum_Gothic_Coding: () => Nanum_Gothic_Coding,
+  Noto_Sans_KR: () => Noto_Sans_KR,
+  createFont: () => createFont,
+  default: () => createFont_default
+});
+module.exports = __toCommonJS(createFont_exports);
+const createFont = (data) => null;
+var createFont_default = createFont;
+const Nanum_Gothic_Coding = createFont;
+const Noto_Sans_KR = createFont;

package/src/csrTypes.cjs

@@ -0,0 +1,51 @@
+"use client";
+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 csrTypes_exports = {};
+__export(csrTypes_exports, {
+  DEFAULT_BOTTOM_INSET: () => DEFAULT_BOTTOM_INSET,
+  DEFAULT_TOP_INSET: () => DEFAULT_TOP_INSET,
+  csrContext: () => csrContext,
+  defaultPageState: () => defaultPageState,
+  pathContext: () => pathContext,
+  useCsr: () => useCsr,
+  usePathCtx: () => usePathCtx
+});
+module.exports = __toCommonJS(csrTypes_exports);
+var import_react = require("react");
+const DEFAULT_TOP_INSET = 48;
+const DEFAULT_BOTTOM_INSET = 60;
+const defaultPageState = {
+  transition: "none",
+  topSafeArea: 0,
+  bottomSafeArea: 0,
+  topInset: 0,
+  bottomInset: 0,
+  gesture: true,
+  cache: false
+};
+const csrContext = (0, import_react.createContext)({});
+const useCsr = () => {
+  const contextValues = (0, import_react.useContext)(csrContext);
+  return contextValues;
+};
+const pathContext = (0, import_react.createContext)({});
+const usePathCtx = () => {
+  const contextValues = (0, import_react.useContext)(pathContext);
+  return contextValues;
+};

package/src/device.cjs

@@ -0,0 +1,127 @@
+"use client";
+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 device_exports = {};
+__export(device_exports, {
+  device: () => device
+});
+module.exports = __toCommonJS(device_exports);
+var import_device = require("@capacitor/device");
+var import_haptics = require("@capacitor/haptics");
+var import_keyboard = require("@capacitor/keyboard");
+var import_capacitor_plugin_safe_area = require("capacitor-plugin-safe-area");
+var import_react_device_detect = require("react-device-detect");
+class Device {
+  info;
+  lang;
+  topSafeArea;
+  bottomSafeArea;
+  isMobile = import_react_device_detect.isMobile;
+  #keyboard = import_keyboard.Keyboard;
+  #haptics = import_haptics.Haptics;
+  #pageContentRef = null;
+  async init({ lang, supportLanguages = [] } = {}) {
+    const [
+      info,
+      { value: languageCode },
+      {
+        insets: { top: topSafeArea, bottom: bottomSafeArea }
+      }
+    ] = await Promise.all([import_device.Device.getInfo(), import_device.Device.getLanguageCode(), import_capacitor_plugin_safe_area.SafeArea.getSafeAreaInsets()]);
+    const predefinedLangPath = window.location.pathname.split("/")[1]?.split("?")[0];
+    const predefinedLang = supportLanguages.find((language) => language === predefinedLangPath);
+    this.info = info;
+    this.lang = lang ?? predefinedLang ?? languageCode;
+    this.topSafeArea = topSafeArea;
+    this.bottomSafeArea = bottomSafeArea;
+  }
+  setPageContentRef(pageContentRef) {
+    this.#pageContentRef = pageContentRef;
+  }
+  async showKeyboard() {
+    if (this.info.platform === "web")
+      return;
+    await this.#keyboard.show();
+  }
+  async hideKeyboard() {
+    if (this.info.platform === "web")
+      return;
+    await this.#keyboard.hide();
+  }
+  listenKeyboardChanged(onKeyboardChanged) {
+    if (this.info.platform === "web")
+      return;
+    void this.#keyboard.addListener("keyboardWillShow", (keyboard) => {
+      onKeyboardChanged(keyboard.keyboardHeight);
+    });
+    void this.#keyboard.addListener("keyboardDidShow", (keyboard) => {
+      onKeyboardChanged(keyboard.keyboardHeight);
+    });
+    void this.#keyboard.addListener("keyboardWillHide", () => {
+      onKeyboardChanged(0);
+    });
+    void this.#keyboard.addListener("keyboardDidHide", () => {
+      onKeyboardChanged(0);
+    });
+  }
+  unlistenKeyboardChanged() {
+    if (this.info.platform === "web")
+      return;
+    void this.#keyboard.removeAllListeners();
+  }
+  async vibrate(type = "medium") {
+    if (typeof type === "number") {
+      await this.#haptics.vibrate({ duration: type });
+      return;
+    }
+    const handleImpact = {
+      light: async () => {
+        await this.#haptics.impact({ style: import_haptics.ImpactStyle.Light });
+      },
+      medium: async () => {
+        await this.#haptics.impact({ style: import_haptics.ImpactStyle.Medium });
+      },
+      heavy: async () => {
+        await this.#haptics.impact({ style: import_haptics.ImpactStyle.Heavy });
+      },
+      selectionStart: async () => {
+        await this.#haptics.selectionStart();
+      },
+      selectionChanged: async () => {
+        await this.#haptics.selectionChanged();
+      },
+      selectionEnd: async () => {
+        await this.#haptics.selectionEnd();
+      }
+    };
+    await handleImpact[type]();
+  }
+  getScrollTop() {
+    if (this.info.platform === "web")
+      return window.scrollY;
+    return this.#pageContentRef?.current?.scrollTop ?? 0;
+  }
+  setScrollTop(scrollTop) {
+    if (this.info.platform === "web") {
+      window.scrollTo({ top: scrollTop });
+      return;
+    }
+    return this.#pageContentRef?.current?.scrollTo({ top: scrollTop });
+  }
+}
+const device = new Device();

package/src/index.cjs

@@ -0,0 +1,23 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./types"), module.exports);
+__reExport(src_exports, require("./csrTypes"), module.exports);
+__reExport(src_exports, require("./router"), module.exports);
+__reExport(src_exports, require("./cookie"), module.exports);
+__reExport(src_exports, require("./storage"), module.exports);
+__reExport(src_exports, require("./device"), module.exports);
+__reExport(src_exports, require("./createFont"), module.exports);

package/src/navigation.cjs

@@ -0,0 +1,47 @@
+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 navigation_exports = {};
+__export(navigation_exports, {
+  NextResponse: () => NextResponse,
+  notFound: () => notFound,
+  redirect: () => redirect,
+  useParams: () => useParams,
+  usePathname: () => usePathname,
+  useRouter: () => useRouter,
+  useSearchParams: () => useSearchParams
+});
+module.exports = __toCommonJS(navigation_exports);
+const notFound = () => {
+  throw new Error("Not found");
+};
+const redirect = (url) => {
+};
+const useParams = () => {
+};
+const usePathname = () => {
+};
+const useRouter = () => {
+};
+const useSearchParams = () => {
+};
+const NextResponse = {
+  next: () => {
+  },
+  redirect: (url) => {
+  }
+};

package/src/router.cjs

@@ -0,0 +1,214 @@
+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 router_exports = {};
+__export(router_exports, {
+  getPathInfo: () => getPathInfo,
+  router: () => router
+});
+module.exports = __toCommonJS(router_exports);
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import_navigation = require("next/navigation");
+const getPathInfo = (href, lang, prefix) => {
+  const langLength = lang.length + 1;
+  const pathWithSubRoute = href === `/${lang}` ? "/" : href.startsWith(`/${lang}/`) ? href.slice(langLength) : href;
+  const prefixLength = prefix ? prefix.length + 1 : 0;
+  const path = !prefixLength ? pathWithSubRoute : pathWithSubRoute === `/${prefix}` ? "/" : pathWithSubRoute.startsWith(`/${prefix}`) ? pathWithSubRoute.slice(prefixLength) : pathWithSubRoute;
+  const subRoute = prefix ? `/${prefix}` : "";
+  const pathname = path.startsWith("http") ? path : path === "/" ? `/${lang}${subRoute}` : `/${lang}${subRoute}${path}`;
+  return { path, pathname };
+};
+class Router {
+  isInitialized = false;
+  #prefix = "";
+  #lang = "en";
+  #instance = {
+    push: (href) => {
+      const { pathname } = this.#getPathInfo(href);
+      import_common.Logger.log(`push to:${pathname}`);
+      if (import_base.baseClientEnv.side === "server")
+        void (0, import_navigation.redirect)(pathname);
+    },
+    replace: (href) => {
+      const { pathname } = this.#getPathInfo(href);
+      import_common.Logger.log(`replace to:${pathname}`);
+      if (import_base.baseClientEnv.side === "server")
+        void (0, import_navigation.redirect)(pathname);
+    },
+    back: () => {
+      throw new Error("back is only available in client");
+    },
+    refresh: () => {
+      throw new Error("refresh is only available in client");
+    }
+  };
+  init(options) {
+    this.#prefix = options.prefix ?? "";
+    this.#lang = options.lang ?? "en";
+    if (options.type === "csr")
+      this.#initCSRClientRouter(options);
+    else if (options.side === "server")
+      this.#initNextServerRouter(options);
+    else
+      this.#initNextClientRouter(options);
+    this.isInitialized = true;
+    import_common.Logger.verbose("Router initialized");
+  }
+  #initNextServerRouter(options) {
+  }
+  #initNextClientRouter(options) {
+    this.#instance = {
+      push: (href) => {
+        const { path, pathname } = this.#getPathInfo(href);
+        this.#postPathChange({ path, pathname });
+        options.router.push(pathname);
+      },
+      replace: (href) => {
+        const { path, pathname } = this.#getPathInfo(href);
+        this.#postPathChange({ path, pathname });
+        options.router.replace(pathname);
+      },
+      back: () => {
+        const { path, pathname } = this.#getPathInfo(document.referrer);
+        this.#postPathChange({ path, pathname });
+        options.router.back();
+      },
+      refresh: () => {
+        const { path, pathname } = this.#getPathInfo(location.pathname);
+        this.#postPathChange({ path, pathname });
+        options.router.refresh();
+      }
+    };
+  }
+  #initCSRClientRouter(options) {
+    this.#instance = {
+      push: (href) => {
+        const { path, pathname } = this.#getPathInfo(href);
+        if (location.pathname === pathname)
+          return;
+        this.#postPathChange({ path, pathname });
+        options.router.push(pathname);
+      },
+      replace: (href) => {
+        const { path, pathname } = this.#getPathInfo(href);
+        if (location.pathname === pathname)
+          return;
+        this.#postPathChange({ path, pathname });
+        options.router.replace(pathname);
+      },
+      back: () => {
+        const { path, pathname } = this.#getPathInfo(document.referrer);
+        if (location.pathname === pathname)
+          return;
+        this.#postPathChange({ path, pathname });
+        options.router.back();
+      },
+      refresh: () => {
+        const { path, pathname } = this.#getPathInfo(location.pathname);
+        this.#postPathChange({ path, pathname });
+        options.router.refresh();
+      }
+    };
+  }
+  #checkInitialized() {
+    if (!this.isInitialized)
+      throw new Error("Router is not initialized");
+  }
+  #getPathInfo(href, prefix = this.#prefix) {
+    return getPathInfo(href, this.#lang, prefix);
+  }
+  #postPathChange({ path, pathname }) {
+    import_common.Logger.log(`pathChange-start:${path}`);
+    window.parent.postMessage({ type: "pathChange", path, pathname }, "*");
+  }
+  push(href) {
+    this.#checkInitialized();
+    this.#instance.push(href);
+    return void 0;
+  }
+  replace(href) {
+    this.#checkInitialized();
+    this.#instance.replace(href);
+    return void 0;
+  }
+  back() {
+    if (import_base.baseClientEnv.side === "server")
+      throw new Error("back is only available in client side");
+    this.#checkInitialized();
+    this.#instance.back();
+    return void 0;
+  }
+  refresh() {
+    if (import_base.baseClientEnv.side === "server")
+      throw new Error("refresh is only available in client side");
+    this.#checkInitialized();
+    this.#instance.refresh();
+    return void 0;
+  }
+  async redirect(href) {
+    if (import_base.baseClientEnv.side === "server") {
+      const nextHeaders = require("next/headers");
+      const headers = await nextHeaders.headers?.() ?? /* @__PURE__ */ new Map();
+      const lang = headers.get("x-locale") ?? this.#lang;
+      const basePath = headers.get("x-base-path");
+      const { pathname } = getPathInfo(href, lang, basePath ?? "");
+      import_common.Logger.log(`redirect to:${pathname}`);
+      (0, import_navigation.redirect)(pathname);
+    } else {
+      const { pathname } = getPathInfo(href, this.#lang, this.#prefix);
+      this.#instance.replace(pathname);
+    }
+    return void 0;
+  }
+  notFound() {
+    this.#checkInitialized();
+    if (import_base.baseClientEnv.side === "server") {
+      import_common.Logger.log(`redirect to:/404`);
+      (0, import_navigation.notFound)();
+    } else
+      this.#instance.replace("/404");
+    return void 0;
+  }
+  setLang(lang) {
+    if (import_base.baseClientEnv.side === "server")
+      throw new Error("setLang is only available in client side");
+    this.#checkInitialized();
+    const { path } = getPathInfo(window.location.pathname, this.#lang, this.#prefix);
+    this.#lang = lang;
+    this.#instance.replace(`/${lang}${path}`);
+    return void 0;
+  }
+  getPath(pathname = window.location.pathname) {
+    if (import_base.baseClientEnv.side === "server")
+      throw new Error("getPath is only available in client side");
+    const { path } = getPathInfo(pathname, this.#lang, this.#prefix);
+    return path;
+  }
+  getFullPath(withLang = true) {
+    if (import_base.baseClientEnv.side === "server")
+      throw new Error("getPath is only available in client side");
+    return `${withLang ? `/${this.#lang}` : ""}/${this.#prefix}${this.getPath()}`;
+  }
+  getPrefix() {
+    return this.#prefix;
+  }
+  getPrefixedPath(path) {
+    return this.#prefix ? `${this.#lang ? `/${this.#lang}` : ""}/${this.#prefix}${path}` : path;
+  }
+}
+const router = new Router();

package/src/storage.cjs

@@ -0,0 +1,54 @@
+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 storage_exports = {};
+__export(storage_exports, {
+  storage: () => storage
+});
+module.exports = __toCommonJS(storage_exports);
+var import_base = require("@akanjs/base");
+var import_preferences = require("@capacitor/preferences");
+const storage = {
+  getItem: async (key) => {
+    if (import_base.baseClientEnv.side === "server")
+      return;
+    if (import_base.baseClientEnv.renderMode === "ssr")
+      return localStorage.getItem(key);
+    else
+      return (await import_preferences.Preferences.get({ key })).value;
+  },
+  setItem: async (key, value) => {
+    if (import_base.baseClientEnv.side === "server")
+      return;
+    if (import_base.baseClientEnv.renderMode === "ssr") {
+      localStorage.setItem(key, value);
+      return;
+    } else {
+      await import_preferences.Preferences.set({ key, value });
+      return;
+    }
+  },
+  removeItem: (key) => {
+    if (import_base.baseClientEnv.side === "server")
+      return;
+    if (import_base.baseClientEnv.renderMode === "ssr") {
+      localStorage.removeItem(key);
+      return;
+    } else
+      return import_preferences.Preferences.remove({ key });
+  }
+};

package/src/types.cjs

@@ -0,0 +1,28 @@
+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 types_exports = {};
+__export(types_exports, {
+  clsx: () => clsx,
+  loadFonts: () => loadFonts
+});
+module.exports = __toCommonJS(types_exports);
+var import_clsx = require("clsx");
+const clsx = (...args) => (0, import_clsx.clsx)(...args);
+const loadFonts = (fonts) => {
+  return fonts.map(({ name, nextFont, paths }) => nextFont ?? { name, paths });
+};