@pitcher/js-api 1.21.0-beta.2 → 1.21.0-beta.3

package/lib/apps/browser/stores/app.d.ts

@@ -0,0 +1,118 @@
+import { Ref, ComputedRef } from 'vue';
+import { File, Folder, Favorite, MiniFolder, FileContentTypeEnum, FileStatusEnum } from '../../../../types/openapi';
+import { CompactFile, CompactFolder } from '@browser/stores/api';
+import { RecentFile } from '../../../types/recentFiles.types';
+
+export type AppName = 'admin' | 'impact';
+export declare enum ViewCompactItemType {
+    File = "file",
+    Folder = "folder"
+}
+export type ViewCompactFolder = Omit<CompactFolder, 'created_by'> & {
+    type: ViewCompactItemType.Folder;
+    favoriteId?: Favorite['id'];
+    content_type?: null;
+    thubmnail_url?: null;
+    file_thumbnail_urls?: string[];
+    folders_count?: number;
+    files_count?: number;
+};
+export type ViewCompactFile = Omit<CompactFile, 'created_by'> & {
+    type: ViewCompactItemType.File;
+    favoriteId?: Favorite['id'];
+    createdBy: string;
+    content_type?: string;
+};
+export type ViewCompactFileFolder = ViewCompactFolder | ViewCompactFile;
+export type RenderableFile = (Favorite & {
+    thumbnail_url?: string;
+    file_thumbnail_urls?: string[];
+}) | RecentFile | ViewCompactFileFolder;
+export type AppCurrentState = 'browse' | 'create-folder' | 'upload-files' | 'update-folder' | 'update-file' | 'batch-move';
+export type BrowserSectionType = 'all' | 'favorites' | 'recent' | 'trash';
+type SelectedItemId = Folder['id'] | File['id'] | RecentFile['id'] | (Favorite['page'] extends {
+    id: any;
+} ? Favorite['page']['id'] : never);
+type View = 'grid' | 'table';
+type RecentFileWithFavoriteId = RecentFile & {
+    favoriteId: string;
+};
+export default function (): {
+    setAppName(appName: AppName): void;
+    resetSelectedItems(): void;
+    removeSelectedItems(removeIds: SelectedItemId[]): void;
+    selectAll(): void;
+    toggleSelectAll(value: boolean): void;
+    toggleItemSelection(item: Partial<File | Folder | Favorite>, { isSelected, disableMultiple }?: {
+        isSelected?: boolean;
+        disableMultiple?: boolean;
+    }): void;
+    toggleSingleItemSelection(item: Partial<File | Folder | Favorite>): void;
+    toggleItemFavorite(item: ViewCompactFileFolder & {
+        favoriteId?: string;
+    }): void;
+    setSelectedSection(section: BrowserSectionType, folderId?: string): void;
+    toggleSelectedView(): void;
+    setSearch(search: string): void;
+    toggleSidebar(isOpen?: boolean): void;
+    toggleContentPanel(isOpen?: boolean): void;
+    selectAndOpenContentPanel(item: ViewCompactFileFolder): void;
+    setCurrentState(stateName: AppCurrentState, itemId?: Folder["id"] | File["id"]): void;
+    clearFilters(): void;
+    clearInlineEditingItem(): void;
+    appName: Ref<AppName | "">;
+    currentState: Ref<AppCurrentState>;
+    selectedItemIds: Ref<SelectedItemId[]>;
+    selectedSection: Ref<BrowserSectionType>;
+    selectedView: Ref<View>;
+    search: Ref<string>;
+    displayedFiles: ComputedRef<ViewCompactFile[]>;
+    displayedFolders: ComputedRef<ViewCompactFolder[]>;
+    displayedFilesFolders: ComputedRef<ViewCompactFileFolder[]>;
+    sortedFavorites: ComputedRef<Favorite[]>;
+    displayedFavorites: ComputedRef<(Favorite & {
+        favoriteId: string;
+    })[]>;
+    displayedRecentFiles: ComputedRef<RecentFileWithFavoriteId[]>;
+    filters: {
+        contentType: {
+            value: Ref<FileContentTypeEnum[]>;
+            optionsRaw: ComputedRef<FileContentTypeEnum[]>;
+            options: ComputedRef<(t: (key: string) => string) => {
+                value: FileContentTypeEnum;
+                label: string;
+            }[]>;
+            show: ComputedRef<boolean>;
+        };
+        status: {
+            value: Ref<FileStatusEnum[]>;
+            optionsRaw: ComputedRef<FileStatusEnum[]>;
+            options: ComputedRef<(t: (key: string) => string) => {
+                value: FileStatusEnum;
+                label: string;
+            }[]>;
+            show: ComputedRef<boolean>;
+        };
+        tag: {
+            value: Ref<string[]>;
+            options: ComputedRef<{
+                value: string;
+                label: string;
+            }[]>;
+            show: ComputedRef<boolean>;
+        };
+        isAnyFilterActive: ComputedRef<boolean>;
+        showClearFilters: ComputedRef<boolean>;
+    };
+    isSidebarOpen: Ref<boolean>;
+    isContentPanelOpen: Ref<boolean>;
+    updatingFolderId: Ref<Folder["id"] | null>;
+    selectedFileId: ComputedRef<File["id"] | null>;
+    selectedFolderId: ComputedRef<Folder["id"] | null>;
+    updatingFolder: ComputedRef<MiniFolder | null>;
+    inlineEditingItem: Ref<{
+        id: string | number;
+        prop: "name" | "tags";
+    } | null>;
+};
+export {};

package/lib/apps/browser/stores/app.test.d.ts

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

package/lib/apps/browser/stores/upload.d.ts

@@ -0,0 +1,101 @@
+import { AccessTypeEnum } from '../../../../types/openapi';
+import { Upload } from '@browser/stores/upload.types';
+
+export default function (): {
+    state: {
+        queue: import('vue').Ref<({
+            id: string;
+            isSupported: boolean;
+            isInLimits: boolean;
+            uploadStatus: import('@browser/stores/upload.types').UploadStatus;
+            error: string | null;
+            cancelErrorMessage: string;
+            genericErrorMessage: string;
+            path: string;
+            content: {
+                name: string;
+                type: string;
+                path: string;
+                size: number;
+            };
+            type?: import('../../../../types/openapi').FileTypeEnum;
+            metadata?: Record<string, any>;
+            name?: string;
+            download_type?: import('../../../../types/openapi').DownloadTypeEnum;
+            access_type?: AccessTypeEnum;
+            app_metadata?: Record<string, any>;
+            tags?: Array<string>;
+            expires_at?: string | null;
+            folder_id?: string;
+            thumbnail?: {
+                readonly size: number;
+                readonly type: string;
+                arrayBuffer: () => Promise<ArrayBuffer>;
+                slice: (start?: number, end?: number, contentType?: string) => Blob;
+                stream: () => ReadableStream<Uint8Array>;
+                text: () => Promise<string>;
+            } | undefined;
+            is_asset?: boolean;
+            content_upload_id?: string;
+            thumbnail_upload_id?: string;
+        } | {
+            id: string;
+            isSupported: boolean;
+            isInLimits: boolean;
+            uploadStatus: import('@browser/stores/upload.types').UploadStatus;
+            error: string | null;
+            cancelErrorMessage: string;
+            genericErrorMessage: string;
+            type?: import('../../../../types/openapi').FileTypeEnum;
+            metadata?: Record<string, any>;
+            content?: {
+                readonly size: number;
+                readonly type: string;
+                arrayBuffer: () => Promise<ArrayBuffer>;
+                slice: (start?: number, end?: number, contentType?: string) => Blob;
+                stream: () => ReadableStream<Uint8Array>;
+                text: () => Promise<string>;
+            } | undefined;
+            name?: string;
+            download_type?: import('../../../../types/openapi').DownloadTypeEnum;
+            access_type?: AccessTypeEnum;
+            app_metadata?: Record<string, any>;
+            tags?: Array<string>;
+            expires_at?: string | null;
+            folder_id?: string;
+            thumbnail?: {
+                readonly size: number;
+                readonly type: string;
+                arrayBuffer: () => Promise<ArrayBuffer>;
+                slice: (start?: number, end?: number, contentType?: string) => Blob;
+                stream: () => ReadableStream<Uint8Array>;
+                text: () => Promise<string>;
+            } | undefined;
+            is_asset?: boolean;
+            content_upload_id?: string;
+            thumbnail_upload_id?: string;
+        })[]>;
+        isQueueBusy: import('vue').ComputedRef<boolean>;
+        uploadSelectedFiles: import('vue').Ref<{
+            readonly lastModified: number;
+            readonly name: string;
+            readonly webkitRelativePath: string;
+            readonly size: number;
+            readonly type: string;
+            arrayBuffer: () => Promise<ArrayBuffer>;
+            slice: (start?: number, end?: number, contentType?: string) => Blob;
+            stream: () => ReadableStream<Uint8Array>;
+            text: () => Promise<string>;
+        }[] | {
+            name: string;
+            type: string;
+            path: string;
+            size: number;
+        }[]>;
+    };
+    actions: {
+        addUploads: (uploads: Upload[], onUploadCompleteCb?: any) => void;
+        removeUpload: (id: Upload["id"]) => void;
+        clearCompletedAndFailed: () => void;
+    };
+};

package/lib/apps/browser/stores/upload.types.d.ts

@@ -0,0 +1,18 @@
+import { FileCreateRequest } from '../../../../types/openapi';
+import { DeviceFile } from '../../../types/files';
+
+export type UploadStatus = 'pending' | 'transferring' | 'failed' | 'completed';
+export type DeviceUploadContent = {
+    path: string;
+    content: DeviceFile;
+} & Omit<FileCreateRequest, 'instance_id' | 'content'>;
+export type FileUploadContent = Omit<FileCreateRequest, 'instance_id'>;
+export type Upload = {
+    id: string;
+    isSupported: boolean;
+    isInLimits: boolean;
+    uploadStatus: UploadStatus;
+    error: string | null;
+    cancelErrorMessage: string;
+    genericErrorMessage: string;
+} & (DeviceUploadContent | FileUploadContent);

package/lib/apps/browser/util/file.d.ts

@@ -0,0 +1,3 @@
+import { RenderableFile } from '@browser/stores/app';
+
+export declare function openFile(item: RenderableFile, e: MouseEvent): void;

package/lib/apps/canvas-builder/App.helpers.d.ts

@@ -0,0 +1,12 @@
+import { UnwrapRef } from 'vue';
+import { ComponentNode } from '@canvas-builder/types/canvas';
+import { SectionComponentNodesBySectionId, ComponentNodesById } from '@canvas-builder/composables/useCanvas';
+
+export declare function navigateToEmbeddableForPages({ appName, canvasPages, componentNodesById, sectionComponentNodesBySectionId, isEditMode, canvasContentElement, }: {
+    appName: string;
+    canvasPages: ComponentNode[][];
+    componentNodesById: UnwrapRef<ComponentNodesById>;
+    sectionComponentNodesBySectionId: UnwrapRef<SectionComponentNodesBySectionId>;
+    isEditMode: boolean;
+    canvasContentElement?: Element;
+}): Promise<void>;

package/lib/apps/canvas-builder/components/ui/Link/Link.util.d.ts

@@ -0,0 +1,13 @@
+import { LinkProps, LinkPreviewTypes } from '@canvas-builder/types/canvas';
+
+export declare function adjustThemeByPreviewType(previewType: LinkPreviewTypes, data?: LinkProps | null): {
+    backgroundColor: string | undefined;
+    color: string | undefined;
+};
+export declare function getPreviewTypeOptions(t: (input: string) => string): {
+    icon: () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }>;
+    label: string;
+    value: LinkPreviewTypes;
+}[];