@akanjs/client 0.0.39 → 0.0.40

package/src/device.js

@@ -0,0 +1,140 @@
+"use client";
+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 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");
+let Device = class Device2 {
+  static {
+    __name(this, "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: /* @__PURE__ */ __name(async () => {
+        await this.#haptics.impact({
+          style: import_haptics.ImpactStyle.Light
+        });
+      }, "light"),
+      medium: /* @__PURE__ */ __name(async () => {
+        await this.#haptics.impact({
+          style: import_haptics.ImpactStyle.Medium
+        });
+      }, "medium"),
+      heavy: /* @__PURE__ */ __name(async () => {
+        await this.#haptics.impact({
+          style: import_haptics.ImpactStyle.Heavy
+        });
+      }, "heavy"),
+      selectionStart: /* @__PURE__ */ __name(async () => {
+        await this.#haptics.selectionStart();
+      }, "selectionStart"),
+      selectionChanged: /* @__PURE__ */ __name(async () => {
+        await this.#haptics.selectionChanged();
+      }, "selectionChanged"),
+      selectionEnd: /* @__PURE__ */ __name(async () => {
+        await this.#haptics.selectionEnd();
+      }, "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,14 @@
+export { DataAction, DataColumn, DataMenu, DataMenuItem, DataTool, MenuItem, ModelDashboardProps, ModelEditProps, ModelInsightProps, ModelProps, ModelViewProps, ModelsProps, ReactFont, RootLayoutProps, UserMenuItem, clsx, loadFonts } from './types.js';
+export { ContainerTransition, CsrConfig, CsrContextType, CsrState, CsrTransitionStyles, DEFAULT_BOTTOM_INSET, DEFAULT_TOP_INSET, History, Location, LocationState, PageState, PageTransition, PathContextType, PathRoute, Route, RouteGuide, RouteState, RouterProps, SafeAreaTransition, TransitionStyle, TransitionType, UseCsrTransition, csrContext, defaultPageState, pathContext, useCsr, usePathCtx } from './csrTypes.js';
+export { RouterInstance, getPathInfo, router } from './router.js';
+export { GetOption, cookies, getAccount, getCookie, getHeader, getMe, getSelf, headers, initAuth, removeCookie, resetAuth, setAuth, setCookie } from './cookie.js';
+export { storage } from './storage.js';
+export { device } from './device.js';
+export { Nanum_Gothic_Coding, Noto_Sans_KR, default as createFont } from './createFont.js';
+import 'dayjs';
+import 'clsx';
+import 'react';
+import '@use-gesture/react/dist/declarations/src/types';
+import 'react-spring';
+import 'js-cookie';
+import '@capacitor/device';

package/src/index.js

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

package/src/navigation.d.ts

@@ -0,0 +1,12 @@
+declare const notFound: () => never;
+declare const redirect: (url: string) => void;
+declare const useParams: () => void;
+declare const usePathname: () => void;
+declare const useRouter: () => void;
+declare const useSearchParams: () => void;
+declare const NextResponse: {
+    next: () => void;
+    redirect: (url: string) => void;
+};
+
+export { NextResponse, notFound, redirect, useParams, usePathname, useRouter, useSearchParams };

package/src/navigation.js

@@ -0,0 +1,58 @@
+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 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 = /* @__PURE__ */ __name(() => {
+  throw new Error("Not found");
+}, "notFound");
+const redirect = /* @__PURE__ */ __name((url) => {
+}, "redirect");
+const useParams = /* @__PURE__ */ __name(() => {
+}, "useParams");
+const usePathname = /* @__PURE__ */ __name(() => {
+}, "usePathname");
+const useRouter = /* @__PURE__ */ __name(() => {
+}, "useRouter");
+const useSearchParams = /* @__PURE__ */ __name(() => {
+}, "useSearchParams");
+const NextResponse = {
+  next: /* @__PURE__ */ __name(() => {
+  }, "next"),
+  redirect: /* @__PURE__ */ __name((url) => {
+  }, "redirect")
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NextResponse,
+  notFound,
+  redirect,
+  useParams,
+  usePathname,
+  useRouter,
+  useSearchParams
+});

package/src/router.d.ts

@@ -0,0 +1,46 @@
+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;
+}
+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;
+    getFullPath(withLang?: boolean): string;
+    getPrefix(): string;
+    getPrefixedPath(path: string): string;
+}
+declare const router: Router;
+
+export { type RouterInstance, getPathInfo, router };

package/src/router.js

@@ -0,0 +1,239 @@
+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 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 = /* @__PURE__ */ __name((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
+  };
+}, "getPathInfo");
+let Router = class Router2 {
+  static {
+    __name(this, "Router");
+  }
+  isInitialized = false;
+  #prefix = "";
+  #lang = "en";
+  #instance = {
+    push: /* @__PURE__ */ __name((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);
+    }, "push"),
+    replace: /* @__PURE__ */ __name((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);
+    }, "replace"),
+    back: /* @__PURE__ */ __name(() => {
+      throw new Error("back is only available in client");
+    }, "back"),
+    refresh: /* @__PURE__ */ __name(() => {
+      throw new Error("refresh is only available in client");
+    }, "refresh")
+  };
+  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: /* @__PURE__ */ __name((href) => {
+        const { path, pathname } = this.#getPathInfo(href);
+        this.#postPathChange({
+          path,
+          pathname
+        });
+        options.router.push(pathname);
+      }, "push"),
+      replace: /* @__PURE__ */ __name((href) => {
+        const { path, pathname } = this.#getPathInfo(href);
+        this.#postPathChange({
+          path,
+          pathname
+        });
+        options.router.replace(pathname);
+      }, "replace"),
+      back: /* @__PURE__ */ __name(() => {
+        const { path, pathname } = this.#getPathInfo(document.referrer);
+        this.#postPathChange({
+          path,
+          pathname
+        });
+        options.router.back();
+      }, "back"),
+      refresh: /* @__PURE__ */ __name(() => {
+        const { path, pathname } = this.#getPathInfo(location.pathname);
+        this.#postPathChange({
+          path,
+          pathname
+        });
+        options.router.refresh();
+      }, "refresh")
+    };
+  }
+  #initCSRClientRouter(options) {
+    this.#instance = {
+      push: /* @__PURE__ */ __name((href) => {
+        const { path, pathname } = this.#getPathInfo(href);
+        if (location.pathname === pathname) return;
+        this.#postPathChange({
+          path,
+          pathname
+        });
+        options.router.push(pathname);
+      }, "push"),
+      replace: /* @__PURE__ */ __name((href) => {
+        const { path, pathname } = this.#getPathInfo(href);
+        if (location.pathname === pathname) return;
+        this.#postPathChange({
+          path,
+          pathname
+        });
+        options.router.replace(pathname);
+      }, "replace"),
+      back: /* @__PURE__ */ __name(() => {
+        const { path, pathname } = this.#getPathInfo(document.referrer);
+        if (location.pathname === pathname) return;
+        this.#postPathChange({
+          path,
+          pathname
+        });
+        options.router.back();
+      }, "back"),
+      refresh: /* @__PURE__ */ __name(() => {
+        const { path, pathname } = this.#getPathInfo(location.pathname);
+        this.#postPathChange({
+          path,
+          pathname
+        });
+        options.router.refresh();
+      }, "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();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPathInfo,
+  router
+});

package/src/storage.d.ts

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

package/src/storage.js

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