@akanjs/client 0.0.39 → 0.0.41

package/index.d.ts

@@ -0,0 +1 @@
+export * from "./src";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/client",
-  "version": "0.0.39",
+  "version": "0.0.41",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"

package/src/cookie.d.ts

@@ -0,0 +1,29 @@
+import { type Account, type Me, type Self } from "@akanjs/signal";
+import Cookies from "js-cookie";
+export declare const cookies: () => Map<string, {
+    name: string;
+    value: string;
+}>;
+export declare const setCookie: (key: string, value: string, options?: Cookies.CookieAttributes) => void;
+export declare const getCookie: (key: string) => string | undefined;
+export declare const removeCookie: (key: string, options?: {
+    path: string;
+}) => boolean | undefined;
+export declare const headers: () => Map<string, string>;
+export declare const getHeader: (key: string) => string | undefined;
+export declare const getAccount: () => Account;
+export interface GetOption {
+    unauthorize: string;
+}
+export declare function getMe<O extends GetOption | undefined>(option?: O): O extends GetOption ? Me : Me | undefined;
+export declare function getSelf<O extends GetOption | undefined>(option?: O): O extends GetOption ? Self : Self | undefined;
+interface SetAuthOption {
+    jwt: string;
+}
+export declare const setAuth: ({ jwt }: SetAuthOption) => void;
+interface InitAuthOption {
+    jwt?: string;
+}
+export declare const initAuth: ({ jwt }?: InitAuthOption) => void;
+export declare const resetAuth: () => void;
+export {};

package/src/createFont.d.ts

@@ -0,0 +1,4 @@
+export declare const createFont: (data: any) => null;
+export default createFont;
+export declare const Nanum_Gothic_Coding: (data: any) => null;
+export declare const Noto_Sans_KR: (data: any) => null;

package/src/csrTypes.d.ts

@@ -0,0 +1,178 @@
+import type { ReactDOMAttributes } from "@use-gesture/react/dist/declarations/src/types";
+import { type ExoticComponent, type MutableRefObject } from "react";
+import { ReactNode } from "react";
+import type { AnimatedComponent, Interpolation, SpringValue } from "react-spring";
+import type { RouterInstance } from "./router";
+export type TransitionType = "none" | "fade" | "bottomUp" | "stack" | "scaleOut";
+export interface CsrConfig {
+    transition?: TransitionType;
+    safeArea?: boolean;
+    topInset?: boolean | number;
+    bottomInset?: boolean | number;
+    gesture?: boolean;
+    cache?: boolean;
+}
+export interface CsrState {
+    transition: TransitionType;
+    topSafeArea: number;
+    bottomSafeArea: number;
+    topInset: number;
+    bottomInset: number;
+    gesture: boolean;
+    cache: boolean;
+}
+export declare const DEFAULT_TOP_INSET = 48;
+export declare const DEFAULT_BOTTOM_INSET = 60;
+export interface Route {
+    csrConfig?: CsrConfig;
+    path: string;
+    Page?: (({ params, searchParams }: {
+        params: any;
+        searchParams: any;
+    }) => ReactNode) | (({ params, searchParams }: {
+        params: any;
+        searchParams: any;
+    }) => Promise<ReactNode>);
+    Layout?: (({ children, params, searchParams }: {
+        children: any;
+        params: any;
+        searchParams: any;
+    }) => ReactNode) | (({ children, params, searchParams }: {
+        children: any;
+        params: any;
+        searchParams: any;
+    }) => Promise<ReactNode>);
+    loader?: () => any;
+    pageState?: PageState;
+    children: Map<string, Route>;
+}
+export type TransitionStyle = NonNullable<AnimatedComponent<ExoticComponent>["defaultProps"]>["style"];
+export interface SafeAreaTransition {
+    containerStyle: TransitionStyle;
+}
+export interface ContainerTransition {
+    containerStyle: TransitionStyle;
+    contentStyle: TransitionStyle;
+    prevContentStyle: TransitionStyle;
+}
+export interface PageTransition {
+    containerStyle: TransitionStyle;
+    contentStyle: TransitionStyle;
+}
+export interface CsrTransitionStyles {
+    topSafeArea: SafeAreaTransition | null;
+    page: PageTransition | null;
+    prevPage: PageTransition | null;
+    topInset: ContainerTransition | null;
+    bottomInset: ContainerTransition | null;
+    topLeftAction: ContainerTransition | null;
+    bottomSafeArea: SafeAreaTransition | null;
+}
+export type PageState = CsrState & {
+    topInset: number;
+    bottomInset: number;
+};
+export declare const defaultPageState: PageState;
+export interface Location {
+    pathname: string;
+    search: string;
+    params: {
+        [key: string]: string;
+    };
+    searchParams: {
+        [key: string]: string | string[];
+    };
+    pathRoute: PathRoute;
+}
+export interface LocationState {
+    location: Location;
+    prevLocation: Location | null;
+}
+export interface History {
+    type: "initial" | "forward" | "back";
+    locations: Location[];
+    scrollMap: Map<string, number>;
+    idxMap: Map<string, number>;
+    cachedLocationMap: Map<string, Location>;
+    idx: number;
+}
+export interface RouterProps {
+    push: (path: string) => void;
+    replace: (path: string) => void;
+    refresh: () => void;
+    back: () => void | Promise<void>;
+}
+export interface RouteState {
+    clientWidth: number;
+    clientHeight: number;
+    location: Location;
+    prevLocation: Location | null;
+    history: MutableRefObject<History>;
+    topSafeAreaRef: MutableRefObject<HTMLDivElement | null>;
+    bottomSafeAreaRef: MutableRefObject<HTMLDivElement | null>;
+    prevPageContentRef: MutableRefObject<HTMLDivElement | null>;
+    pageContentRef: MutableRefObject<HTMLDivElement | null>;
+    frameRootRef: MutableRefObject<HTMLDivElement | null>;
+    onBack: MutableRefObject<{
+        [K in TransitionType]?: () => Promise<void>;
+    }>;
+    router: RouterInstance;
+    pathRoutes: PathRoute[];
+}
+export type UseCsrTransition = CsrTransitionStyles & {
+    pageBind: (...args: any[]) => ReactDOMAttributes;
+    pageClassName: string;
+    transDirection: "vertical" | "horizontal" | "none";
+    transUnitRange: number[];
+    transUnit: SpringValue<number>;
+    transPercent: Interpolation<number>;
+    transProgress: Interpolation<number>;
+};
+export type CsrContextType = RouteState & UseCsrTransition;
+export declare const csrContext: import("react").Context<CsrContextType>;
+export declare const useCsr: () => CsrContextType;
+export interface PathContextType {
+    pageType: "current" | "prev" | "cached";
+    location: Location;
+    gestureEnabled: boolean;
+    setGestureEnabled: (enabled: boolean) => void;
+}
+export declare const pathContext: import("react").Context<PathContextType>;
+export declare const usePathCtx: () => PathContextType;
+export interface PathRoute {
+    path: string;
+    pathSegments: string[];
+    Page: (({ params, searchParams }: {
+        params: any;
+        searchParams: any;
+    }) => ReactNode) | (({ params, searchParams }: {
+        params: any;
+        searchParams: any;
+    }) => Promise<ReactNode>);
+    pageState: PageState;
+    RootLayouts: ((({ children, params, searchParams }: {
+        children: any;
+        params: any;
+        searchParams: any;
+    }) => ReactNode) | (({ children, params, searchParams }: {
+        children: any;
+        params: any;
+        searchParams: any;
+    }) => Promise<ReactNode>))[];
+    Layouts: ((({ children, params, searchParams }: {
+        children: any;
+        params: any;
+        searchParams: any;
+    }) => ReactNode) | (({ children, params, searchParams }: {
+        children: any;
+        params: any;
+        searchParams: any;
+    }) => Promise<ReactNode>))[];
+}
+export interface RouteGuide {
+    pathSegment: string;
+    pathRoute?: PathRoute;
+    children: {
+        [key: string]: RouteGuide;
+    };
+}

package/src/device.d.ts

@@ -0,0 +1,25 @@
+import { type DeviceInfo } from "@capacitor/device";
+import type { MutableRefObject } from "react";
+interface DeviceInitOption {
+    lang?: string;
+    supportLanguages?: string[] | readonly string[];
+}
+declare class Device {
+    #private;
+    info: DeviceInfo;
+    lang: string;
+    topSafeArea: number;
+    bottomSafeArea: number;
+    isMobile: boolean;
+    init({ lang, supportLanguages }?: DeviceInitOption): Promise<void>;
+    setPageContentRef(pageContentRef: MutableRefObject<HTMLDivElement | null>): void;
+    showKeyboard(): Promise<void>;
+    hideKeyboard(): Promise<void>;
+    listenKeyboardChanged(onKeyboardChanged: (height: number) => void): void;
+    unlistenKeyboardChanged(): void;
+    vibrate(type?: "light" | "medium" | "heavy" | number): Promise<void>;
+    getScrollTop(): number;
+    setScrollTop(scrollTop: number): void;
+}
+export declare const device: Device;
+export {};

package/src/index.d.ts

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

package/src/router.d.ts

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

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/types.d.ts

@@ -0,0 +1,110 @@
+import type { FetchInitForm } from "@akanjs/signal";
+import { type ClassValue } from "clsx";
+import type { ReactNode } from "react";
+export declare const clsx: (...args: ClassValue[]) => string;
+export declare const loadFonts: (fonts: {
+    name: string;
+    nextFont: any;
+    paths: {
+        src: string;
+        weight: number;
+    }[];
+}[]) => ReactFont[];
+export interface ModelsProps<M extends {
+    id: string;
+}> {
+    className?: string;
+    sliceName?: string;
+    query?: {
+        [key: string]: any;
+    };
+    init?: FetchInitForm<any, M, any>;
+    onClickItem?: (model: M) => any;
+}
+export type ModelProps<T extends string, L extends {
+    id: string;
+}> = {
+    [key in T]: L;
+} & {
+    className?: string;
+    sliceName?: T;
+    onClick?: (model: L) => any;
+    actions?: DataAction<L>[];
+    columns?: DataColumn<L>[];
+    href?: string;
+};
+export interface ModelDashboardProps<Summary> {
+    className?: string;
+    summary: Summary;
+    queryMap?: {
+        [key: string]: any;
+    };
+    columns?: (keyof Summary)[];
+    hidePresents?: boolean;
+    sliceName?: string;
+}
+export interface ModelInsightProps<Insight> {
+    className?: string;
+    insight: Insight;
+    sliceName?: string;
+}
+export interface ModelEditProps {
+    sliceName?: string;
+}
+export interface ModelViewProps {
+    id?: string;
+    sliceName?: string;
+}
+export type DataAction<L> = "edit" | "view" | "remove" | {
+    type: string;
+    render: () => ReactNode;
+};
+export interface DataTool {
+    render: () => ReactNode;
+}
+export type DataColumn<L> = string | {
+    key: keyof L;
+    title?: string;
+    value?: (value: any, model: L) => string | number | boolean | undefined | null | object;
+    responsive?: boolean;
+    render?: (value: any, model: L) => ReactNode;
+    only?: "user" | "admin";
+};
+export interface DataMenuItem {
+    key: string;
+    icon: ReactNode;
+    label?: string;
+    render: () => ReactNode;
+}
+export interface DataMenu {
+    [key: string]: DataMenuItem;
+}
+export interface UserMenuItem {
+    title: string | ReactNode;
+    icon?: ReactNode;
+    path: string;
+    query?: any;
+    children?: UserMenuItem[];
+    onClick?: () => void;
+}
+export interface MenuItem {
+    icon?: ReactNode;
+    title: string | ReactNode;
+    href: string;
+    hide?: "mobile" | "pc";
+    children?: MenuItem[];
+    onClick?: () => void;
+}
+export interface ReactFont {
+    name: string;
+    paths: {
+        src: string;
+        weight: number;
+    }[];
+}
+export interface RootLayoutProps {
+    children: ReactNode;
+    params: Promise<{
+        lang: "en" | "ko";
+    }>;
+}