@akanjs/client 0.0.4

package/src/device.js

@@ -0,0 +1,131 @@
+"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();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  device
+});

package/src/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./types";
+export * from "./storeDecorators";
+export * from "./csrTypes";
+export * from "./router";
+export * from "./cookie";
+export * from "./storage";
+export * from "./device";
+export * from "./createFont";

package/src/index.js

@@ -0,0 +1,35 @@
+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("./storeDecorators"), 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);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./types"),
+  ...require("./storeDecorators"),
+  ...require("./csrTypes"),
+  ...require("./router"),
+  ...require("./cookie"),
+  ...require("./storage"),
+  ...require("./device"),
+  ...require("./createFont")
+});

package/src/router.d.ts

@@ -0,0 +1,44 @@
+export interface RouterInstance {
+    push: (href: string) => void;
+    replace: (href: string) => void;
+    back: () => void;
+    refresh: () => void;
+}
+interface RouterOptions {
+    prefix?: string;
+    lang?: string;
+}
+interface NextServerRouterOption extends RouterOptions {
+    type: "next";
+    side: "server";
+}
+interface NextClientRouterOption extends RouterOptions {
+    type: "next";
+    side: "client";
+    router: RouterInstance;
+}
+interface CSRClientRouterOption extends RouterOptions {
+    type: "csr";
+    router: RouterInstance;
+}
+export declare const getPathInfo: (href: string, lang: string, prefix: string) => {
+    path: string;
+    pathname: string;
+};
+declare class Router {
+    #private;
+    isInitialized: boolean;
+    init(options: NextClientRouterOption | NextServerRouterOption | CSRClientRouterOption): void;
+    push(href: string): never;
+    replace(href: string): never;
+    back(): never;
+    refresh(): never;
+    redirect(href: string): Promise<never>;
+    notFound(): never;
+    setLang(lang: string): never;
+    getPath(pathname?: string): string;
+    getPrefix(): string;
+    getPrefixedPath(path: string): string;
+}
+export declare const router: Router;
+export {};

package/src/router.js

@@ -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;
+  }
+  getPrefix() {
+    return this.#prefix;
+  }
+  getPrefixedPath(path) {
+    return this.#prefix ? `${this.#lang ? `/${this.#lang}` : ""}/${this.#prefix}${path}` : path;
+  }
+}
+const router = new Router();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPathInfo,
+  router
+});

package/src/storage.d.ts

@@ -0,0 +1,5 @@
+export declare const storage: {
+    getItem: (key: string) => Promise<string | null | undefined>;
+    setItem: (key: string, value: string) => Promise<void>;
+    removeItem: (key: string) => Promise<void> | undefined;
+};

package/src/storage.js

@@ -0,0 +1,58 @@
+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 });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  storage
+});