orgnote-api 0.20.2 → 0.40.0

package/models/index.js

@@ -11,16 +11,73 @@ export * from "./default-commands.js";
 export * from "./encryption.js";
 export * from "./file-system.js";
 export * from "./sync.js";
-export * from "./file-cache.js";
+export * from "./file-info.js";
 export * from "./file-path.js";
-export * from "./file-tree.js";
 export * from "./user.js";
 export * from "./oauth-provider.js";
+export * from "./orgnote-config.js";
+export * from "./platform-specific.js";
+export * from "./css-utils.js";
+export * from "./i18n-keys.js";
+export * from "./vue-component.js";
+export * from "./file-upload.js";
+export * from "./confirmation-modal.js";
+export * from "./pane.js";
+export * from "./buffer.js";
+export * from "./log.js";
+export * from "./logger.js";
+export * from "./layout.js";
+export * from "./menu-action.js";
+export * from "./queue-task.js";
+export * from "./cron-task.js";
+export * from "./platform.js";
+export * from "./platform-detection.js";
+export * from "./git.js";
+export * from "./file-guard.js";
+export * from "./file-guard-store.js";
+// Composables
+export * from "./splash-screen.js";
+export * from "./screen-detection.js";
+export * from "./system-info.js";
 // Stores
 export * from "./sync-store.js";
 export * from "./files-store.js";
 export * from "./file-opener-store.js";
 export * from "./file-manager-store.js";
 export * from "./auth-store.js";
+export * from "./commands-store.js";
+export * from "./commands-group-store.js";
+export * from "./extension-store.js";
+export * from "./file-system-store.js";
+export * from "./file-watcher-store.js";
+export * from "./settings-store.js";
+export * from "./encryption-store.js";
+export * from "./ui-store.js";
+export * from "./sidebar-store.js";
+export * from "./toolbar-store.js";
+export * from "./modal-store.js";
+export * from "./settings-ui-store.js";
+export * from "./completion-store.js";
+export * from "./panes-store.js";
+export * from "./layout-store.js";
+export * from "./file-system-manager-store.js";
+export * from "./config-store.js";
+export * from "./notifications-store.js";
+export * from "./notification-config.js";
+export * from "./buffer-store.js";
+export * from "./log-store.js";
+export * from "./context-menu-store.js";
+export * from "./queue-store.js";
+export * from "./cron-store.js";
+export * from "./git-store.js";
+export * from "./extension-registry-store.js";
+export * from "./theme-store.js";
+// UI
+export * from "./style-variant.js";
+export * from "./style-size.js";
 // Repositories
 export * from "./repositories.js";
+export * from "./log-repository.js";
+export * from "./layout-snapshot-repository.js";
+// URL
+export * from "./orgnote-url.js";

package/models/layout-snapshot-repository.d.ts

@@ -0,0 +1,14 @@
+import { LayoutSnapshot } from './pane.js';
+export interface StoredLayoutSnapshot {
+    id: string;
+    createdAt: string;
+    snapshot: LayoutSnapshot;
+}
+export interface LayoutSnapshotRepository {
+    save(snapshot: LayoutSnapshot, id?: string): Promise<void>;
+    get(id: string): Promise<StoredLayoutSnapshot | undefined>;
+    getLatest(): Promise<StoredLayoutSnapshot | undefined>;
+    list(limit?: number): Promise<StoredLayoutSnapshot[]>;
+    delete(id: string): Promise<void>;
+    clear(): Promise<void>;
+}

package/models/layout-snapshot-repository.js

@@ -0,0 +1 @@
+export {};

package/models/layout-store.d.ts

@@ -0,0 +1,17 @@
+import { ShallowRef } from 'vue';
+import { StoreDefinition } from './store.js';
+import { LayoutNode, DropDirection as SplitDirection } from './layout.js';
+import { LayoutSnapshot } from './pane.js';
+export interface LayoutStore {
+    layout: ShallowRef<LayoutNode | undefined>;
+    initLayout: (layout?: LayoutNode) => Promise<void>;
+    splitPaneInLayout: (paneId: string, direction: SplitDirection, createInitialTab?: boolean) => Promise<string | undefined>;
+    removePaneFromLayout: (paneId: string) => void;
+    updateNodeSizes: (nodeId: string, sizes: number[]) => void;
+    normalizeSizes: (sizes: number[]) => number[];
+    saveLayout: () => Promise<void>;
+    restoreLayout: () => Promise<void>;
+    getLayoutSnapshot: () => LayoutSnapshot | undefined;
+    restoreLayoutSnapshot: (snapshot: LayoutSnapshot) => Promise<void>;
+}
+export type LayoutStoreDefinition = StoreDefinition<LayoutStore>;

package/models/layout-store.js

@@ -0,0 +1 @@
+export {};

package/models/layout.d.ts

@@ -0,0 +1,16 @@
+export type LayoutOrientation = 'horizontal' | 'vertical';
+export type DropZone = 'left' | 'right' | 'top' | 'bottom' | 'center';
+export type DropDirection = 'left' | 'right' | 'top' | 'bottom';
+export type LayoutNode = LayoutPaneNode | LayoutSplitNode;
+export interface LayoutPaneNode {
+    type: 'pane';
+    id: string;
+    paneId: string;
+}
+export interface LayoutSplitNode {
+    type: 'split';
+    id: string;
+    orientation: LayoutOrientation;
+    children: LayoutNode[];
+    sizes?: number[];
+}

package/models/layout.js

@@ -0,0 +1 @@
+export {};

package/models/log-repository.d.ts

@@ -0,0 +1,17 @@
+import { LogLevel, LogRecord } from './log.js';
+export interface LogFilter {
+    level?: LogLevel;
+    from?: Date;
+    to?: Date;
+    text?: string;
+    limit?: number;
+    offset?: number;
+}
+export interface LoggerRepository {
+    add(record: LogRecord): Promise<void>;
+    bulkAdd(records: LogRecord[]): Promise<void>;
+    query(filter: LogFilter): Promise<LogRecord[]>;
+    count(filter?: Omit<LogFilter, 'limit' | 'offset'>): Promise<number>;
+    clear(): Promise<void>;
+    purgeOlderThan(date: Date): Promise<void>;
+}

package/models/log-repository.js

@@ -0,0 +1 @@
+export {};

package/models/log-store.d.ts

@@ -0,0 +1,15 @@
+import type { Ref } from 'vue';
+import { StoreDefinition } from './store.js';
+import { LogRecord, LogLevel } from './log.js';
+export interface LogStore {
+    logs: Ref<LogRecord[]>;
+    addLog: (log: LogRecord) => void;
+    addLogs: (logs: LogRecord[]) => void;
+    getLogsByLevel: (level: LogLevel) => LogRecord[];
+    getLogsSince: (timestamp: Date) => LogRecord[];
+    getCountByLevel: (level: LogLevel) => number;
+    clearLogs: () => void;
+    clearLogsByLevel: (level: LogLevel) => void;
+    exportAsText: () => string;
+}
+export type LogStoreDefinition = StoreDefinition<LogStore>;

package/models/log-store.js

@@ -0,0 +1 @@
+export {};

package/models/log.d.ts

@@ -0,0 +1,12 @@
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'trace';
+export interface LogRecord {
+    id?: number;
+    ts: Date;
+    level: LogLevel;
+    message: string;
+    bindings?: Record<string, unknown>;
+    context?: Record<string, unknown>;
+    repeatCount?: number;
+    firstTs?: Date;
+    lastTs?: Date;
+}

package/models/log.js

@@ -0,0 +1 @@
+export {};

package/models/logger.d.ts

@@ -0,0 +1,8 @@
+export interface Logger {
+    info: (msg: string, ...args: unknown[]) => void;
+    error: (msg: string, ...args: unknown[]) => void;
+    warn: (msg: string, ...args: unknown[]) => void;
+    debug: (msg: string, ...args: unknown[]) => void;
+    trace: (msg: string, ...args: unknown[]) => void;
+    child: (bindings: Record<string, unknown>) => Logger;
+}

package/models/logger.js

@@ -0,0 +1 @@
+export {};

package/models/menu-action.d.ts

@@ -0,0 +1,18 @@
+import { CommandName } from './command.js';
+type DefinedMenuGroup = 'file' | 'dir' | 'tab';
+export type MenuGroup = DefinedMenuGroup | (string & {});
+export interface MenuActionBase<T = unknown> {
+    icon?: string;
+    title?: string;
+}
+export interface ManualMenuAction<T = unknown> extends MenuActionBase<T> {
+    handler: (data: T) => void;
+}
+export interface CommandMenuAction extends MenuActionBase {
+    command: CommandName;
+}
+export type MenuAction = ManualMenuAction | CommandMenuAction;
+export interface MenuGroupParams {
+    items: MenuAction[];
+}
+export {};

package/models/menu-action.js

@@ -0,0 +1 @@
+export {};

package/models/modal-store.d.ts

@@ -0,0 +1,16 @@
+import type { Ref, ShallowRef } from 'vue';
+import { StoreDefinition } from './store.js';
+import { VueComponent } from './vue-component.js';
+import { Modal, ModalConfig } from './modal.js';
+import { ComputedRef } from 'vue';
+export interface ModalStore {
+    open: <TReturn = unknown>(cmp: VueComponent, config?: ModalConfig) => Promise<TReturn>;
+    title: Ref<string | undefined>;
+    close: <TReturn = unknown>(data?: TReturn) => void;
+    component: ComputedRef<VueComponent | undefined>;
+    config: ComputedRef<ModalConfig | undefined>;
+    closeAll: () => void;
+    modals: ShallowRef<Modal[]>;
+    updateConfig: (config: Partial<ModalConfig>) => void;
+}
+export type ModalStoreDefinition = StoreDefinition<ModalStore>;

package/models/modal-store.js

@@ -0,0 +1 @@
+export {};

package/models/modal.d.ts

@@ -1,10 +1,18 @@
 import { VueComponent } from './vue-component.js';
-export interface ModalConfig<T = unknown> {
+export interface ModalConfig<T = any> {
     closable?: boolean;
     title?: string;
     modalProps?: T;
+    modalEmits?: Record<string, (params: any) => any>;
+    position?: 'top' | 'center' | 'bottom';
+    fullScreen?: boolean;
+    noPadding?: boolean;
+    wide?: boolean;
+    mini?: boolean;
+    headerTitleComponent?: VueComponent;
 }
-export interface Modal {
+export interface Modal<TReturn = any> {
     config?: ModalConfig;
+    closed?: Promise<TReturn>;
     component: VueComponent;
 }

package/models/note.d.ts

@@ -1,23 +1,40 @@
-import type { ModelsPublicNote, ModelsPublicUser } from '../remote-api/index.js';
+import type { EncryptionType } from './encryption.js';
 export interface NotesFilter {
     searchText?: string;
     userId?: string;
     limit?: number;
     offset?: number;
 }
-export interface NotePreview {
-    id: ModelsPublicNote['id'];
-    meta: ModelsPublicNote['meta'];
-    createdAt: ModelsPublicNote['createdAt'];
-    updatedAt: ModelsPublicNote['updatedAt'];
-    filePath: ModelsPublicNote['filePath'];
-    isMy: ModelsPublicNote['isMy'];
-    author?: ModelsPublicUser;
-    bookmarked?: boolean;
-    encrypted?: boolean;
+export interface NoteMeta {
+    id?: string;
+    title?: string;
+    description?: string;
+    fileTags?: string[];
+    previewImg?: string;
+    published?: boolean;
+    startup?: string;
+    images?: string[];
+    connectedNotes?: Record<string, string>;
+}
+export interface PublicUser {
+    id?: string;
+    name?: string;
+    nickName?: string;
+    avatarUrl?: string;
+    email?: string;
+    profileUrl?: string;
 }
-export interface Note extends Omit<ModelsPublicNote, 'content'> {
-    deleted?: Date;
+export interface NoteInfo {
+    id?: string;
+    meta: NoteMeta;
+    createdAt?: string;
+    encryptionType?: EncryptionType;
+    updatedAt?: string;
+    touchedAt?: string;
+    deletedAt?: string;
+    filePath?: string[];
+    isMy?: boolean;
+    author?: PublicUser;
     bookmarked?: boolean;
     encrypted?: boolean;
 }

package/models/notification-config.d.ts

@@ -0,0 +1,14 @@
+import { StyleVariant } from './style-variant.js';
+export interface NotificationConfig {
+    id?: string;
+    message: string;
+    description?: string;
+    group?: boolean;
+    timeout?: number;
+    level?: StyleVariant;
+    caption?: string;
+    closable?: boolean;
+    icon?: string;
+    iconEnabled?: boolean;
+    onClick?: () => void;
+}

package/models/notification-config.js

@@ -0,0 +1 @@
+export {};

package/models/notifications-store.d.ts

@@ -0,0 +1,20 @@
+import type { Notify } from 'quasar';
+import { NotificationConfig } from './notification-config.js';
+import { StoreDefinition } from './store.js';
+import { Ref } from 'vue';
+export interface Notification {
+    read?: boolean;
+    config: NotificationConfig;
+    dismiss?: ReturnType<typeof Notify.create>;
+    icon?: string;
+    iconEnabled?: boolean;
+}
+export interface NotificationsStore {
+    notify: (config: NotificationConfig) => void;
+    clear: () => void;
+    hideAll: () => void;
+    delete: (notificationId: string) => void;
+    markAsRead: (notificationId: string) => void;
+    notifications: Ref<Notification[]>;
+}
+export type NotificationsStoreDefinition = StoreDefinition<NotificationsStore>;

package/models/notifications-store.js

@@ -0,0 +1 @@
+export {};

package/models/oauth-provider.d.ts

@@ -1 +1,2 @@
-export type OAuthProvider = 'github' | 'google';
+import { OAUTH_PROVIDERS } from "../constants/index.js";
+export type OAuthProvider = (typeof OAUTH_PROVIDERS)[number];

package/models/orgnote-config.d.ts

@@ -0,0 +1,80 @@
+import { InferOutput } from 'valibot';
+export declare const ORG_NOTE_CONFIG_SCHEMA: import("valibot").SchemaWithPipe<readonly [import("valibot").ObjectWithRestSchema<{
+    readonly editor: import("valibot").ObjectSchema<{
+        readonly showSpecialSymbols: import("valibot").BooleanSchema<undefined>;
+        readonly showPropertyDrawer: import("valibot").BooleanSchema<undefined>;
+        readonly saveDelayMs: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        readonly validationDelayMs: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    }, undefined>;
+    readonly developer: import("valibot").ObjectSchema<{
+        readonly developerMode: import("valibot").BooleanSchema<undefined>;
+        readonly maximumLogsCount: import("valibot").NumberSchema<undefined>;
+        readonly storeQueueTasksMinutes: import("valibot").NumberSchema<undefined>;
+        readonly corsProxy: import("valibot").StringSchema<undefined>;
+    }, undefined>;
+    readonly completion: import("valibot").ObjectSchema<{
+        readonly showGroup: import("valibot").BooleanSchema<undefined>;
+        readonly defaultCompletionLimit: import("valibot").NumberSchema<undefined>;
+        readonly fuseThreshold: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    }, undefined>;
+    readonly system: import("valibot").ObjectSchema<{
+        readonly language: import("valibot").StringSchema<undefined>;
+    }, undefined>;
+    readonly synchronization: import("valibot").ObjectSchema<{
+        readonly type: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"none", undefined>, import("valibot").LiteralSchema<"api", undefined>], undefined>;
+    }, undefined>;
+    readonly ui: import("valibot").ObjectSchema<{
+        readonly showUserProfiles: import("valibot").BooleanSchema<undefined>;
+        readonly theme: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"light", undefined>, import("valibot").LiteralSchema<"dark", undefined>, import("valibot").LiteralSchema<"auto", undefined>], undefined>;
+        readonly darkThemeName: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").LiteralSchema<any, undefined>], undefined>, undefined>;
+        readonly lightThemeName: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").LiteralSchema<any, undefined>], undefined>, undefined>;
+        readonly enableAnimations: import("valibot").BooleanSchema<undefined>;
+        readonly notificationTimeout: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        readonly persistantPanes: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+        readonly persistantPanesSaveDelay: import("valibot").NumberSchema<undefined>;
+        readonly dropZoneEdgeRatio: import("valibot").NumberSchema<undefined>;
+    }, undefined>;
+    readonly extensions: import("valibot").ObjectSchema<{
+        readonly sources: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+    }, undefined>;
+    readonly encryption: import("valibot").IntersectSchema<[import("valibot").ObjectSchema<{
+        readonly encryptFilesByDefault: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    }, undefined>, import("valibot").SchemaWithPipe<readonly [import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+        readonly type: import("valibot").LiteralSchema<"gpgKeys", undefined>;
+        readonly privateKey: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MetadataAction<string, {
+            readonly textarea: true;
+            readonly upload: true;
+        }>]>;
+        readonly publicKey: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>, import("valibot").MetadataAction<string, {
+            readonly textarea: true;
+            readonly upload: true;
+        }>]>;
+        readonly privateKeyPassphrase: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    }, undefined>, import("valibot").ObjectSchema<{
+        readonly type: import("valibot").LiteralSchema<"gpgPassword", undefined>;
+        readonly password: import("valibot").StringSchema<undefined>;
+    }, undefined>, import("valibot").ObjectSchema<{
+        readonly type: import("valibot").LiteralSchema<"disabled", undefined>;
+    }, undefined>], undefined>, import("valibot").MetadataAction<{
+        type: "gpgKeys";
+        privateKey: string;
+        publicKey?: string;
+        privateKeyPassphrase?: string;
+    } | {
+        type: "gpgPassword";
+        password: string;
+    } | {
+        type: "disabled";
+    }, {
+        readonly conditionalKey: "type";
+    }>]>], undefined>;
+}, import("valibot").UnknownSchema, undefined>]>;
+export interface DefinedOrgNoteSettings {
+    vault?: string;
+}
+export type OrgNoteSettings = DefinedOrgNoteSettings & {
+    [key: string]: unknown;
+};
+export type OrgNoteConfig = InferOutput<typeof ORG_NOTE_CONFIG_SCHEMA> & {
+    [key: string]: any;
+};

package/models/orgnote-config.js

@@ -0,0 +1,42 @@
+import { object, boolean, number, string, union, optional, array, literal, pipe, unknown, objectWithRest, } from 'valibot';
+import { OrgNoteEncryptionSchema } from "./encryption.js";
+export const ORG_NOTE_CONFIG_SCHEMA = pipe(objectWithRest({
+    editor: object({
+        showSpecialSymbols: boolean(),
+        showPropertyDrawer: boolean(),
+        saveDelayMs: optional(number()),
+        validationDelayMs: optional(number()),
+    }),
+    developer: object({
+        developerMode: boolean(),
+        maximumLogsCount: number(),
+        storeQueueTasksMinutes: number(),
+        corsProxy: string(),
+    }),
+    completion: object({
+        showGroup: boolean(),
+        defaultCompletionLimit: number(),
+        fuseThreshold: optional(number()),
+    }),
+    system: object({
+        language: string(),
+    }),
+    synchronization: object({
+        type: union([literal('none'), literal('api')]),
+    }),
+    ui: object({
+        showUserProfiles: boolean(),
+        theme: union([literal('light'), literal('dark'), literal('auto')]),
+        darkThemeName: optional(union([string(), literal(null)])),
+        lightThemeName: optional(union([string(), literal(null)])),
+        enableAnimations: boolean(),
+        notificationTimeout: optional(number()),
+        persistantPanes: optional(boolean()),
+        persistantPanesSaveDelay: number(),
+        dropZoneEdgeRatio: number(),
+    }),
+    extensions: object({
+        sources: array(string()),
+    }),
+    encryption: OrgNoteEncryptionSchema,
+}, unknown()));

package/models/orgnote-url.d.ts

@@ -0,0 +1,6 @@
+export type UrlTarget = 'native-app' | 'web';
+export interface BuildOrgNoteUrlOptions {
+    query?: Record<string, string>;
+    target?: UrlTarget;
+}
+export type BuildOrgNoteUrl = (path: string, options?: BuildOrgNoteUrlOptions) => string;

package/models/orgnote-url.js

@@ -0,0 +1 @@
+export {};

package/models/pane.d.ts

@@ -0,0 +1,38 @@
+import { ShallowRef } from 'vue';
+import type { Router } from 'vue-router';
+import type { LayoutNode } from './layout.js';
+export interface Pane {
+    id: string;
+    activeTabId: string;
+    tabs: ShallowRef<Record<string, Tab>>;
+}
+export interface Tab {
+    title: string;
+    id: string;
+    paneId: string;
+    router: Router;
+}
+export type InitialTabParams = Partial<Pick<Tab, 'title' | 'id' | 'paneId'>>;
+export interface TabSnapshot {
+    id: string;
+    title: string;
+    paneId: string;
+    routeLocation: {
+        path: string;
+        params: Record<string, string>;
+        query: Record<string, string>;
+        hash: string;
+        name?: string;
+    };
+}
+export interface PaneSnapshot {
+    id: string;
+    activeTabId: string;
+    tabs: TabSnapshot[];
+}
+export interface LayoutSnapshot {
+    panes: PaneSnapshot[];
+    activePaneId: string;
+    timestamp: number;
+    layout: LayoutNode;
+}

package/models/pane.js

@@ -0,0 +1 @@
+export {};

package/models/panes-store.d.ts

@@ -0,0 +1,30 @@
+import { Ref, ShallowRef, ComputedRef } from 'vue';
+import { StoreDefinition } from './store.js';
+import { InitialTabParams, Tab, Pane, PaneSnapshot } from './pane.js';
+import type { RouteLocationRaw } from 'vue-router';
+export interface PaneStore {
+    panes: Ref<Record<string, ShallowRef<Pane>>>;
+    activePaneId: Ref<string | undefined>;
+    activePane: ComputedRef<Pane | undefined>;
+    activeTab: ComputedRef<Tab | undefined>;
+    createPane: (params?: Partial<Pane>) => Promise<Pane>;
+    getPane: (id: string) => ShallowRef<Pane | undefined>;
+    closePane: (paneId: string) => void;
+    setActivePane: (paneId: string) => void;
+    isDraggingTab: Ref<boolean>;
+    draggedTabData: Ref<{
+        tabId: string;
+        paneId: string;
+    } | undefined>;
+    initNewTab: (params?: InitialTabParams) => Promise<Tab>;
+    addTab: (paneId: string, params?: InitialTabParams) => Promise<Tab | undefined>;
+    closeTab: (paneId: string, tabId: string) => Promise<boolean>;
+    selectTab: (paneId: string, tabId: string) => void;
+    moveTab: (tabId: string, fromPaneId: string, toPaneId: string, index?: number) => Promise<Tab | undefined>;
+    navigate: (params: RouteLocationRaw, paneId?: string, tabId?: string) => Promise<void>;
+    startDraggingTab: (tabId: string, paneId: string) => void;
+    stopDraggingTab: () => void;
+    getPanesData: () => PaneSnapshot[];
+    restorePanesData: (panes: PaneSnapshot[]) => Promise<void>;
+}
+export type PaneStoreDefinition = StoreDefinition<PaneStore>;

package/models/panes-store.js

@@ -0,0 +1 @@
+export {};

package/models/platform-detection.d.ts

@@ -0,0 +1,11 @@
+export type PlatformType = 'mobile' | 'desktop' | 'capacitor' | 'nativeMobile' | 'electron' | 'linux' | 'mac' | 'win' | 'chrome' | 'firefox' | 'opera' | 'safari' | 'webkit' | 'ios' | 'ipad' | 'iphone' | 'ipod' | 'winphone' | 'blackberry' | 'android' | 'cordova' | 'pwa' | 'ssr' | 'bex';
+export interface PlatformDetection {
+    is: Record<PlatformType, boolean>;
+    current: PlatformType[];
+}
+export type PlatformHandler<T> = {
+    [K in PlatformType]?: () => T | Promise<T>;
+} & {
+    default: () => T | Promise<T>;
+};
+export type PlatformMatch = <T>(handlers: PlatformHandler<T>) => Promise<T>;

package/models/platform-detection.js

@@ -0,0 +1 @@
+export {};

package/models/platform-specific.d.ts

@@ -0,0 +1 @@
+export type PlatformSpecificFn = <T extends (...params: any[]) => any>(fn?: T, defaultValue?: Awaited<ReturnType<T>> | Promise<Awaited<ReturnType<T>>>) => (...params: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;

package/models/platform-specific.js

@@ -0,0 +1 @@
+export {};

package/models/platform.d.ts

@@ -0,0 +1,2 @@
+import type { Platform as QuasarPlatform } from 'quasar';
+export type Platform = Exclude<keyof QuasarPlatform['is'], 'name' | 'platform' | 'version' | 'versionNumber'>;

package/models/platform.js

@@ -0,0 +1 @@
+export {};