@opencloud-eu/web-pkg 4.0.0 → 4.1.0

package/dist/src/services/archiver.d.ts

@@ -0,0 +1,25 @@
+import { ClientService } from '../services';
+import { Ref } from 'vue';
+import { ArchiverCapability } from '@opencloud-eu/web-client/ocs';
+import { UserStore } from '../composables';
+interface TriggerDownloadOptions {
+    dir?: string;
+    files?: string[];
+    fileIds?: string[];
+    downloadSecret?: string;
+    publicToken?: string;
+    publicLinkPassword?: string;
+}
+export declare class ArchiverService {
+    clientService: ClientService;
+    userStore: UserStore;
+    serverUrl: string;
+    capability: Ref<ArchiverCapability>;
+    available: Ref<boolean>;
+    constructor(clientService: ClientService, userStore: UserStore, serverUrl: string, archiverCapabilities?: Ref<ArchiverCapability[]>);
+    triggerDownload(options: TriggerDownloadOptions): Promise<string>;
+    private buildDownloadUrl;
+    private get url();
+    private getFileNameFromResponseHeaders;
+}
+export {};

package/dist/src/services/cache.d.ts

@@ -0,0 +1,14 @@
+import { Cache } from '../helpers/cache';
+declare class CacheService {
+    get avatarUrl(): Cache<string, {
+        size?: number;
+        src?: string;
+    }>;
+    get filePreview(): Cache<string, {
+        etag?: string;
+        src?: string;
+        dimensions?: [number, number];
+    }>;
+}
+export declare const cacheService: CacheService;
+export {};

package/dist/src/services/client/auth.d.ts

@@ -0,0 +1,12 @@
+export interface AuthParameters {
+    accessToken?: string;
+    publicLinkToken?: string;
+    publicLinkPassword?: string;
+}
+export declare class Auth {
+    accessToken?: string;
+    publicLinkToken?: string;
+    publicLinkPassword?: string;
+    constructor(params?: AuthParameters);
+    getHeaders(): Record<string, string>;
+}

package/dist/src/services/client/client.d.ts

@@ -0,0 +1,48 @@
+import { HttpClient } from '../../http';
+import { Graph } from '@opencloud-eu/web-client/graph';
+import { OCS } from '@opencloud-eu/web-client/ocs';
+import { WebDAV } from '@opencloud-eu/web-client/webdav';
+import { Language } from 'vue3-gettext';
+import { AuthStore, ConfigStore } from '../../composables';
+export interface ClientServiceOptions {
+    configStore: ConfigStore;
+    language: Language;
+    authStore: AuthStore;
+}
+export declare class ClientService {
+    private configStore;
+    private language;
+    private authStore;
+    private httpAuthenticatedClient;
+    private httpUnAuthenticatedClient;
+    private graphClient;
+    private ocsClient;
+    private webDavClient;
+    initiatorId: string;
+    private staticHeaders;
+    constructor(options: ClientServiceOptions);
+    get httpAuthenticated(): HttpClient;
+    get httpUnAuthenticated(): HttpClient;
+    get graphAuthenticated(): Graph;
+    get sseAuthenticated(): EventSource;
+    get ocs(): OCS;
+    /** @deprecated use `ocs()` instead */
+    get ocsUserContext(): OCS;
+    /** @deprecated use `ocs()` instead */
+    ocsPublicLinkContext(password?: string): OCS;
+    get webdav(): WebDAV;
+    get currentLanguage(): string;
+    getRequestHeaders: ({ useAuth }?: {
+        useAuth?: boolean;
+    }) => {
+        [x: string]: string;
+    };
+    private initGraphClient;
+    private initOcsClient;
+    private initWebDavClient;
+    /**
+     * Dynamic headers that should be provided via callback or interceptor because they may
+     * change during the lifetime of the application (e.g. token renewal).
+     */
+    private getDynamicHeaders;
+}

package/dist/src/services/client/index.d.ts

@@ -0,0 +1,2 @@
+export * from './auth';
+export * from './client';

package/dist/src/services/eventBus.d.ts

@@ -0,0 +1,8 @@
+export declare class EventBus {
+    private topics;
+    constructor();
+    subscribe<T = unknown>(topic: string, callback: (data?: T) => void): string;
+    publish(topic: string, data?: unknown): void;
+    unsubscribe(topic: string, token: string): void;
+}
+export declare const eventBus: EventBus;

package/dist/src/services/folder/folderService.d.ts

@@ -0,0 +1,27 @@
+import { Router } from 'vue-router';
+import { Task } from 'vue-concurrency';
+import { UserStore, SpacesStore, CapabilityStore, ConfigStore, ResourcesStore, SharesStore, AuthServiceInterface } from '../../composables';
+import { ClientService } from '../../services';
+export type FolderLoaderTask<T = any, TT = any> = Task<T, TT[]>;
+export type TaskContext = {
+    clientService: ClientService;
+    configStore: ConfigStore;
+    userStore: UserStore;
+    spacesStore: SpacesStore;
+    router: Router;
+    capabilityStore: CapabilityStore;
+    resourcesStore: ResourcesStore;
+    sharesStore: SharesStore;
+    authService: AuthServiceInterface;
+};
+export interface FolderLoader {
+    isEnabled(): boolean;
+    isActive(router: Router): boolean;
+    getTask(options: TaskContext): FolderLoaderTask;
+}
+export declare class FolderService {
+    private readonly loaders;
+    constructor();
+    getTask(): FolderLoaderTask;
+}
+export declare const folderService: FolderService;

package/dist/src/services/folder/index.d.ts

@@ -0,0 +1,2 @@
+export * from './folderService';
+export * from './loaders';

package/dist/src/services/folder/loaders/index.d.ts

@@ -0,0 +1,7 @@
+export * from './loaderSpace';
+export * from './loaderFavorites';
+export * from './loaderSharedViaLink';
+export * from './loaderSharedWithMe';
+export * from './loaderSharedWithOthers';
+export * from './loaderTrashbin';
+export * from './types';

package/dist/src/services/folder/loaders/loaderFavorites.d.ts

@@ -0,0 +1,7 @@
+import { FolderLoader, FolderLoaderTask, TaskContext } from '../folderService';
+import { Router } from 'vue-router';
+export declare class FolderLoaderFavorites implements FolderLoader {
+    isEnabled(): boolean;
+    isActive(router: Router): boolean;
+    getTask(context: TaskContext): FolderLoaderTask;
+}

package/dist/src/services/folder/loaders/loaderSharedViaLink.d.ts

@@ -0,0 +1,7 @@
+import { FolderLoader, FolderLoaderTask, TaskContext } from '../folderService';
+import { Router } from 'vue-router';
+export declare class FolderLoaderSharedViaLink implements FolderLoader {
+    isEnabled(): boolean;
+    isActive(router: Router): boolean;
+    getTask(context: TaskContext): FolderLoaderTask;
+}

package/dist/src/services/folder/loaders/loaderSharedWithMe.d.ts

@@ -0,0 +1,7 @@
+import { FolderLoader, FolderLoaderTask, TaskContext } from '../folderService';
+import { Router } from 'vue-router';
+export declare class FolderLoaderSharedWithMe implements FolderLoader {
+    isEnabled(): boolean;
+    isActive(router: Router): boolean;
+    getTask(context: TaskContext): FolderLoaderTask;
+}

package/dist/src/services/folder/loaders/loaderSharedWithOthers.d.ts

@@ -0,0 +1,7 @@
+import { FolderLoader, FolderLoaderTask, TaskContext } from '../folderService';
+import { Router } from 'vue-router';
+export declare class FolderLoaderSharedWithOthers implements FolderLoader {
+    isEnabled(): boolean;
+    isActive(router: Router): boolean;
+    getTask(context: TaskContext): FolderLoaderTask;
+}

package/dist/src/services/folder/loaders/loaderSpace.d.ts

@@ -0,0 +1,7 @@
+import { FolderLoader, FolderLoaderTask, TaskContext } from '../folderService';
+import { Router } from 'vue-router';
+export declare class FolderLoaderSpace implements FolderLoader {
+    isEnabled(): boolean;
+    isActive(router: Router): boolean;
+    getTask(context: TaskContext): FolderLoaderTask;
+}

package/dist/src/services/folder/loaders/loaderTrashbin.d.ts

@@ -0,0 +1,7 @@
+import { FolderLoader, FolderLoaderTask, TaskContext } from '../folderService';
+import { Router } from 'vue-router';
+export declare class FolderLoaderTrashbin implements FolderLoader {
+    isEnabled(): boolean;
+    isActive(router: Router): boolean;
+    getTask(context: TaskContext): FolderLoaderTask;
+}

package/dist/src/services/folder/loaders/types.d.ts

@@ -0,0 +1,3 @@
+export interface FolderLoaderOptions {
+    loadShares?: boolean;
+}

package/dist/src/services/index.d.ts

@@ -0,0 +1,10 @@
+export * from './appProvider';
+export * from './archiver';
+export * from './cache';
+export * from './client';
+export * from './eventBus';
+export * from './folder';
+export * from './loadingService';
+export * from './preview';
+export * from './passwordPolicy';
+export * from './uppy';

package/dist/src/services/loadingService.d.ts

@@ -0,0 +1,33 @@
+export declare enum LoadingEventTopics {
+    add = "loading-service.add",
+    remove = "loading-service.remove",
+    setProgress = "loading-service.set-progress"
+}
+export interface LoadingTaskState {
+    total: number;
+    current: number;
+}
+export interface LoadingTask {
+    id: string;
+    active: boolean;
+    state?: LoadingTaskState;
+}
+export interface LoadingTaskCallbackArguments {
+    setProgress: (args: LoadingTaskState) => void;
+}
+export declare class LoadingService {
+    private tasks;
+    get isLoading(): boolean;
+    /**
+     * Get the current progress from 0 to 100.
+     * Returns null if at least one task is indeterminate.
+     */
+    get currentProgress(): number | null;
+    addTask<T>(callback: ({ setProgress }: LoadingTaskCallbackArguments) => Promise<T>, { debounceTime, indeterminate }?: {
+        debounceTime?: number;
+        indeterminate?: boolean;
+    }): Promise<T>;
+    private removeTask;
+    private setProgress;
+    private onBeforeUnload;
+}

package/dist/src/services/passwordPolicy/index.d.ts

@@ -0,0 +1 @@
+export * from './passwordPolicy';

package/dist/src/services/passwordPolicy/passwordPolicy.d.ts

@@ -0,0 +1,20 @@
+import { Language } from 'vue3-gettext';
+import { CapabilityStore } from '../../composables';
+import { PasswordPolicy } from 'password-sheriff';
+export declare class PasswordPolicyService {
+    private readonly language;
+    private capability;
+    private policy;
+    private generatePasswordRules;
+    constructor({ language }: {
+        language: Language;
+    });
+    initialize(capabilityStore: CapabilityStore): void;
+    private hasRules;
+    private buildGeneratePasswordRules;
+    private buildPolicy;
+    getPolicy({ enforcePassword }?: {
+        enforcePassword?: boolean;
+    }): PasswordPolicy;
+    generatePassword(): string;
+}

package/dist/src/services/passwordPolicy/rules.d.ts

@@ -0,0 +1,69 @@
+import { Language } from 'vue3-gettext';
+export interface PasswordPolicyRuleOptions {
+    minLength?: number;
+    maxLength?: number;
+    characters?: string;
+}
+export interface PasswordPolicyRuleExplained {
+    code: string;
+    message: string;
+    helperMessage?: string;
+    format: (number | string)[];
+    verified?: boolean;
+}
+export interface PasswordPolicyRule {
+    assert(options: PasswordPolicyRuleOptions, password: string): boolean;
+    explain(options: PasswordPolicyRuleOptions, verified?: boolean): PasswordPolicyRuleExplained;
+    missing(options: PasswordPolicyRuleOptions, password: string): PasswordPolicyRuleExplained;
+    validate(options?: PasswordPolicyRuleOptions): boolean;
+}
+export declare class MustNotBeEmptyRule implements PasswordPolicyRule {
+    protected $gettext: (msgid: string, parameters?: {
+        [key: string]: string;
+    }, disableHtmlEscaping?: boolean) => string;
+    constructor({ $gettext }: Language);
+    explain(options: PasswordPolicyRuleOptions, verified: boolean): PasswordPolicyRuleExplained;
+    assert(options: PasswordPolicyRuleOptions, password: string): boolean;
+    validate(): boolean;
+    missing(options: PasswordPolicyRuleOptions, password: string): PasswordPolicyRuleExplained;
+}
+export declare class MustContainRule implements PasswordPolicyRule {
+    protected $gettext: (msgid: string, parameters?: {
+        [key: string]: string;
+    }, disableHtmlEscaping?: boolean) => string;
+    constructor({ $gettext }: Language);
+    explain(options: PasswordPolicyRuleOptions, verified: boolean): PasswordPolicyRuleExplained;
+    assert(options: PasswordPolicyRuleOptions, password: string): boolean;
+    validate(options: PasswordPolicyRuleOptions): boolean;
+    missing(options: PasswordPolicyRuleOptions, password: string): PasswordPolicyRuleExplained;
+}
+export declare class AtLeastBaseRule implements PasswordPolicyRule {
+    protected $gettext: (msgid: string, parameters?: {
+        [key: string]: string;
+    }, disableHtmlEscaping?: boolean) => string;
+    constructor({ $gettext }: Language);
+    assert(options: PasswordPolicyRuleOptions, password: string): boolean;
+    explain(options: PasswordPolicyRuleOptions, verified?: boolean): PasswordPolicyRuleExplained;
+    validate(options: PasswordPolicyRuleOptions): boolean;
+    missing(options: PasswordPolicyRuleOptions, password: string): PasswordPolicyRuleExplained;
+}
+export declare class AtLeastCharactersRule extends AtLeastBaseRule implements PasswordPolicyRule {
+    constructor(args: Language);
+    explain(options: PasswordPolicyRuleOptions, verified: boolean): PasswordPolicyRuleExplained;
+    assert(options: PasswordPolicyRuleOptions, password: string): boolean;
+}
+export declare class AtLeastUppercaseCharactersRule extends AtLeastBaseRule {
+    constructor(args: Language);
+    explain(options: PasswordPolicyRuleOptions, verified: boolean): PasswordPolicyRuleExplained;
+    assert(options: PasswordPolicyRuleOptions, password: string): boolean;
+}
+export declare class AtLeastLowercaseCharactersRule extends AtLeastBaseRule {
+    constructor(args: Language);
+    explain(options: PasswordPolicyRuleOptions, verified: boolean): PasswordPolicyRuleExplained;
+    assert(options: PasswordPolicyRuleOptions, password: string): boolean;
+}
+export declare class AtLeastDigitsRule extends AtLeastBaseRule {
+    constructor(args: Language);
+    explain(options: PasswordPolicyRuleOptions, verified: boolean): PasswordPolicyRuleExplained;
+    assert(options: PasswordPolicyRuleOptions, password: string): boolean;
+}

package/dist/src/services/preview/index.d.ts

@@ -0,0 +1,2 @@
+export * from './previewService';
+export * from './types';

package/dist/src/services/preview/previewService.d.ts

@@ -0,0 +1,21 @@
+import { ClientService } from '../client';
+import { LoadPreviewOptions } from '.';
+import { AuthStore, ConfigStore, UserStore } from '../../composables';
+export declare class PreviewService {
+    clientService: ClientService;
+    configStore: ConfigStore;
+    userStore: UserStore;
+    authStore: AuthStore;
+    constructor({ clientService, userStore, authStore, configStore }: {
+        clientService: ClientService;
+        userStore: UserStore;
+        authStore: AuthStore;
+        configStore: ConfigStore;
+    });
+    private get user();
+    loadPreview(options: LoadPreviewOptions, cached?: boolean, silenceErrors?: boolean, signal?: AbortSignal): Promise<string | undefined>;
+    private cacheFactory;
+    private buildQueryString;
+    private privatePreviewBlob;
+    private publicPreviewUrl;
+}

package/dist/src/services/preview/types.d.ts

@@ -0,0 +1,23 @@
+import { Resource, SpaceResource } from '@opencloud-eu/web-client';
+import { z } from 'zod';
+export declare const ProcessorType: z.ZodEnum<{
+    fill: "fill";
+    thumbnail: "thumbnail";
+    resize: "resize";
+    fit: "fit";
+}>;
+export type ProcessorType = z.infer<typeof ProcessorType>;
+export interface BuildQueryStringOptions {
+    preview?: number;
+    scalingup?: number;
+    a?: number;
+    etag?: string;
+    dimensions?: [number, number];
+    processor?: ProcessorType;
+}
+export interface LoadPreviewOptions {
+    space: SpaceResource;
+    resource: Resource;
+    dimensions?: [number, number];
+    processor?: ProcessorType;
+}

package/dist/src/services/uppy/DropTarget/getDroppedFiles.d.ts

@@ -0,0 +1 @@
+export declare const getDroppedFiles: (dataTransfer: DataTransfer, logDropError?: (error?: Error) => void) => Promise<File[]>;

package/dist/src/services/uppy/DropTarget/plugin.d.ts

@@ -0,0 +1,21 @@
+import { Body, DefinePluginOpts, Meta, Uppy, BasePlugin } from '@uppy/core';
+import { DropTargetOptions } from './types';
+declare const defaultOpts: DropTargetOptions;
+/**
+ * This is an adaption of the official Uppy DropTarget plugin, extended by the
+ * functionality to handle empty folders and integrated into our UppyService.
+ * https://github.com/transloadit/uppy/tree/main/packages/%40uppy/drop-target
+ */
+export default class DropTarget<M extends Meta, B extends Body> extends BasePlugin<Partial<DefinePluginOpts<DropTargetOptions, keyof typeof defaultOpts>>, M, B> {
+    private nodes?;
+    private uppyService?;
+    constructor(uppy: Uppy<M, B>, opts?: DropTargetOptions);
+    handleDrop: (event: DragEvent) => Promise<void>;
+    handleDragOver: (event: DragEvent) => void;
+    handleDragLeave: (event: DragEvent) => void;
+    addListeners: () => void;
+    removeListeners: () => void;
+    install(): void;
+    uninstall(): void;
+}
+export {};

package/dist/src/services/uppy/DropTarget/types.d.ts

@@ -0,0 +1,9 @@
+import { PluginOpts } from '@uppy/core';
+import { UppyService } from '../uppyService';
+export interface DropTargetOptions extends PluginOpts {
+    target?: HTMLElement | string | null;
+    uppyService?: UppyService;
+    onDrop?: (event: DragEvent) => void;
+    onDragOver?: (event: DragEvent) => void;
+    onDragLeave?: (event: DragEvent) => void;
+}

package/dist/src/services/uppy/index.d.ts

@@ -0,0 +1,2 @@
+export * from './uppyService';
+export * from './utils';

package/dist/src/services/uppy/uppyService.d.ts

@@ -0,0 +1,91 @@
+import { default as Uppy, BasePlugin, UnknownPlugin, UppyFile } from '@uppy/core';
+import { TusOptions } from '@uppy/tus';
+import { XHRUploadOptions } from '@uppy/xhr-upload';
+import { Language } from 'vue3-gettext';
+import { Resource } from '@opencloud-eu/web-client';
+import { Body, MinimalRequiredUppyFile } from '@uppy/utils';
+type UppyServiceTopics = 'uploadStarted' | 'uploadCancelled' | 'uploadCompleted' | 'uploadSuccess' | 'uploadError' | 'filesSelected' | 'progress' | 'addedForUpload' | 'upload-progress' | 'drag-over' | 'drag-out' | 'drop';
+export type uppyHeaders = {
+    [name: string]: string | number;
+};
+export type UploadResult = {
+    successful: OcUppyFile[];
+    failed: OcUppyFile[];
+    uploadID?: string;
+};
+interface UppyServiceOptions {
+    language: Language;
+}
+export type OcUppyMeta = {
+    name?: string;
+    mtime?: number;
+    spaceId: string;
+    spaceName: string;
+    driveAlias: string;
+    driveType: string;
+    currentFolder: string;
+    currentFolderId?: string;
+    fileId?: string;
+    uppyId?: string;
+    relativeFolder: string;
+    relativePath: string;
+    tusEndpoint: string;
+    uploadId: string;
+    topLevelFolderId?: string;
+    routeName?: string;
+    routeDriveAliasAndItem?: string;
+    routeShareId?: string;
+    isFolder: boolean;
+};
+export type OcUppyBody = Body;
+export type OcUppyFile = UppyFile<OcUppyMeta, OcUppyBody>;
+type OcUppyPlugin = typeof BasePlugin<any, OcUppyMeta, OcUppyBody>;
+export type OcMinimalUppyFile = MinimalRequiredUppyFile<OcUppyMeta, OcUppyBody>;
+export type OcTusOptions = TusOptions<OcUppyMeta, OcUppyBody>;
+/** `OmitFirstArg<typeof someArray>` is the type of the returned value of `someArray.slice(1)`. */
+type OmitFirstArg<T> = T extends [any, ...infer U] ? U : never;
+export declare class UppyService {
+    uppy: Uppy<OcUppyMeta, OcUppyBody>;
+    uploadInputs: HTMLInputElement[];
+    uploadFolderMap: Record<string, Resource>;
+    constructor({ language }: UppyServiceOptions);
+    getRelativeFilePath: (file: OcUppyFile) => string | undefined;
+    addPlugin<T extends OcUppyPlugin>(Plugin: T, ...args: OmitFirstArg<ConstructorParameters<T>>): void;
+    removePlugin(plugin: UnknownPlugin<OcUppyMeta, OcUppyBody>): void;
+    getPlugin<T extends UnknownPlugin<OcUppyMeta, OcUppyBody> = UnknownPlugin<OcUppyMeta, OcUppyBody>>(name: string): T | undefined;
+    useTus({ chunkSize, overridePatchMethod, uploadDataDuringCreation, onBeforeRequest, headers }: TusOptions<OcUppyMeta, OcUppyBody>): void;
+    useXhr({ headers, timeout, endpoint }: XHRUploadOptions<OcUppyMeta, OcUppyBody>): void;
+    tusActive(): boolean;
+    useDropTarget({ targetSelector }: {
+        targetSelector: string;
+    }): void;
+    removeDropTarget(): void;
+    subscribe<T>(topic: UppyServiceTopics, callback: (data?: T) => void): string;
+    unsubscribe(topic: UppyServiceTopics, token: string): void;
+    publish(topic: UppyServiceTopics, data?: unknown): void;
+    private setUpEvents;
+    registerUploadInput(el: HTMLInputElement): void;
+    removeUploadInput(el: HTMLInputElement): void;
+    generateUploadId(uppyFile: OcUppyFile): string;
+    log(message: unknown, type?: 'error' | 'warning'): void;
+    addFiles(files: OcMinimalUppyFile[] | File[]): void;
+    uploadFiles(): Promise<import('@uppy/core').UploadResult<OcUppyMeta, Body>>;
+    retryAllUploads(): Promise<import('@uppy/core').UploadResult<OcUppyMeta, Body>>;
+    pauseAllUploads(): void;
+    resumeAllUploads(): void;
+    cancelAllUploads(): void;
+    removeFailedFiles(): void;
+    getCurrentUploads(): Record<string, unknown>;
+    isRemoteUploadInProgress(): boolean;
+    clearInputs(): void;
+    /**
+     * Set a specific upload folder for an upload. The HandleUpload plugin
+     * checks, if a specific folder has been specified as upload destination.
+     * If not, it falls back to the current folder.
+     * The uploadId needs to be set within the meta object of the upload files
+     * for the plugin to connect an upload to its destination folder.
+     **/
+    setUploadFolder(uploadId: string, folder: Resource): void;
+    removeUploadFolder(uploadId: string): void;
+}
+export {};

package/dist/src/services/uppy/utils.d.ts

@@ -0,0 +1,11 @@
+import { OcMinimalUppyFile } from './uppyService';
+/**
+ * Constructs a file-like object for a given folder path. This acts as a dummy
+ * to represent folders in the Uppy queue.
+ */
+export declare const createFolderDummyFile: (path: string) => File;
+/**
+ * Converts a list of files to the minimal Uppy file format.
+ * This is used to add files to the Uppy queue via addFiles() (see below).
+ */
+export declare const convertToMinimalUppyFile: (source: string, files: File[]) => OcMinimalUppyFile[];

package/dist/src/types.d.ts

@@ -0,0 +1,24 @@
+export interface AncestorMetaDataValue {
+    id: string;
+    shareTypes: number[];
+    parentFolderId: string;
+    spaceId: string;
+    path: string;
+}
+export type AncestorMetaData = Record<string, AncestorMetaDataValue>;
+export type FederatedUser = {
+    display_name: string;
+    idp: string;
+    mail: string;
+    user_id: string;
+};
+export type FederatedConnection = FederatedUser & {
+    id: string;
+};
+export interface UpdateChannel {
+    current_version: string;
+    url: string;
+}
+export interface Updates {
+    channels: Record<string, UpdateChannel>;
+}

package/dist/src/ui/index.d.ts

@@ -0,0 +1 @@
+export * from './types';

package/dist/src/ui/types.d.ts

@@ -0,0 +1,14 @@
+import { IconFillType } from '../helpers/resource';
+import { Component } from 'vue';
+export type FolderView = {
+    name: string;
+    label: string;
+    icon: {
+        name: string;
+        fillType: IconFillType;
+    };
+    /** @deprecated style your view with proper CSS instead */
+    isScrollable?: boolean;
+    component: Component;
+    componentAttrs?: () => Record<string, unknown>;
+};

package/dist/src/utils/dirname.d.ts

@@ -0,0 +1 @@
+export { dirname } from 'path';

package/dist/src/utils/encodePath.d.ts

@@ -0,0 +1 @@
+export declare const encodePath: (path?: string) => string;

package/dist/src/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './dirname';
+export * from './encodePath';
+export * from './objectKeys';
+export * from './semver';
+export * from './types';

package/dist/src/utils/objectKeys.d.ts

@@ -0,0 +1 @@
+export declare const objectKeys: (obj: Record<string, unknown>) => string[];

package/dist/src/utils/semver.d.ts

@@ -0,0 +1,14 @@
+export declare const parseVersion: (tag: string) => {
+    major: number;
+    minor: number;
+    patch: number;
+    pre: string;
+};
+/**
+ * Compares two version strings.
+ * Returns:
+ * - negative number if a is less than b,
+ * - positive number if a is greater than b,
+ * - 0 if a and b are equal.
+ */
+export declare const compareVersions: (a: string, b: string) => number;

package/dist/src/utils/types.d.ts

@@ -0,0 +1,5 @@
+import { Ref, MaybeRef } from 'vue';
+export type StringUnionOrAnyString<T extends string> = T | Omit<string, T>;
+export type ReadOnlyRef<T> = Readonly<Ref<T>>;
+export type MaybeReadonlyRef<T> = MaybeRef<T> | ReadOnlyRef<T>;
+export type { MaybeRef } from 'vue';