@sdcorejs/angular 19.2.14 → 19.2.15
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/components/button/src/button.component.d.ts +5 -0
- package/components/file-explorer/index.d.ts +2 -0
- package/components/file-explorer/src/components/file-icon.component.d.ts +15 -0
- package/components/file-explorer/src/components/folder-tree.component.d.ts +29 -0
- package/components/file-explorer/src/components/item-list.component.d.ts +34 -0
- package/components/file-explorer/src/components/preview-panel.component.d.ts +52 -0
- package/components/file-explorer/src/components/transfer-panel.component.d.ts +29 -0
- package/components/file-explorer/src/file-explorer-icons.generated.d.ts +8 -0
- package/components/file-explorer/src/file-explorer.component.d.ts +135 -0
- package/components/file-explorer/src/file-explorer.model.d.ts +268 -0
- package/components/file-explorer/src/file-explorer.utils.d.ts +54 -0
- package/components/file-explorer/src/file-explorer.view-model.d.ts +90 -0
- package/components/index.d.ts +1 -0
- package/components/side-drawer/src/side-drawer.component.d.ts +12 -1
- package/fesm2022/sdcorejs-angular-components-api-contract-builder.mjs +1 -1
- package/fesm2022/sdcorejs-angular-components-api-contract-builder.mjs.map +1 -1
- package/fesm2022/sdcorejs-angular-components-button.mjs +12 -2
- package/fesm2022/sdcorejs-angular-components-button.mjs.map +1 -1
- package/fesm2022/sdcorejs-angular-components-file-explorer.mjs +2582 -0
- package/fesm2022/sdcorejs-angular-components-file-explorer.mjs.map +1 -0
- package/fesm2022/sdcorejs-angular-components-form-generic.mjs +1 -1
- package/fesm2022/sdcorejs-angular-components-form-generic.mjs.map +1 -1
- package/fesm2022/sdcorejs-angular-components-preview.mjs +2 -2
- package/fesm2022/sdcorejs-angular-components-preview.mjs.map +1 -1
- package/fesm2022/sdcorejs-angular-components-side-drawer.mjs +91 -6
- package/fesm2022/sdcorejs-angular-components-side-drawer.mjs.map +1 -1
- package/fesm2022/sdcorejs-angular-components-table.mjs +1 -1
- package/fesm2022/sdcorejs-angular-components-table.mjs.map +1 -1
- package/fesm2022/sdcorejs-angular-components.mjs +1 -0
- package/fesm2022/sdcorejs-angular-components.mjs.map +1 -1
- package/fesm2022/sdcorejs-angular-i18n.mjs +430 -0
- package/fesm2022/sdcorejs-angular-i18n.mjs.map +1 -1
- package/fesm2022/sdcorejs-angular-modules-icon.mjs +6 -0
- package/fesm2022/sdcorejs-angular-modules-icon.mjs.map +1 -1
- package/i18n/src/en.d.ts +85 -0
- package/package.json +9 -5
|
@@ -39,6 +39,11 @@ export declare class SdButton implements OnInit, OnDestroy {
|
|
|
39
39
|
block: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
40
40
|
htmlType: import("@angular/core").InputSignalWithTransform<SdButtonHtmlType, SdButtonHtmlType | null | undefined>;
|
|
41
41
|
autoId: import("@angular/core").Signal<string | undefined>;
|
|
42
|
+
/**
|
|
43
|
+
* Accessible name of the trigger. Menu triggers use title/tooltip; icon-only buttons use the tooltip
|
|
44
|
+
* because their icon is `aria-hidden` and they have no visible text.
|
|
45
|
+
*/
|
|
46
|
+
readonly ariaLabel: import("@angular/core").Signal<string | null>;
|
|
42
47
|
buttonClasses: import("@angular/core").Signal<{
|
|
43
48
|
'c-square': boolean;
|
|
44
49
|
'c-sm': boolean;
|
|
@@ -0,0 +1,15 @@
|
|
|
1
|
+
import type { SdFileExplorerIconName } from '../file-explorer-icons.generated';
|
|
2
|
+
import * as i0 from "@angular/core";
|
|
3
|
+
/**
|
|
4
|
+
* Built-in file-type icon (folder, PDF, spreadsheet, image, code…), drawn from the embedded SVG set.
|
|
5
|
+
* Decorative: always `aria-hidden` with an empty `alt`, the item name next to it carries the meaning.
|
|
6
|
+
*/
|
|
7
|
+
export declare class SdFileExplorerFileIcon {
|
|
8
|
+
/** Icon to draw. */
|
|
9
|
+
readonly icon: import("@angular/core").InputSignal<SdFileExplorerIconName>;
|
|
10
|
+
/** Rendered size in pixels (the SVGs use a 64 × 64 canvas with built-in padding). */
|
|
11
|
+
readonly size: import("@angular/core").InputSignal<number>;
|
|
12
|
+
protected readonly src: import("@angular/core").Signal<string>;
|
|
13
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<SdFileExplorerFileIcon, never>;
|
|
14
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<SdFileExplorerFileIcon, "sd-file-explorer-file-icon", never, { "icon": { "alias": "icon"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
|
|
15
|
+
}
|
|
@@ -0,0 +1,29 @@
|
|
|
1
|
+
import type { SdFileExplorerTreeNode } from '../file-explorer.view-model';
|
|
2
|
+
import * as i0 from "@angular/core";
|
|
3
|
+
/**
|
|
4
|
+
* Folder tree of the explorer (internal). Rendered as a flat `role="tree"` list whose depth is carried by
|
|
5
|
+
* `aria-level`, with a roving tabindex and the WAI-ARIA tree keyboard model.
|
|
6
|
+
*/
|
|
7
|
+
export declare class SdFileExplorerFolderTree {
|
|
8
|
+
#private;
|
|
9
|
+
/** Visible nodes in display order. */
|
|
10
|
+
readonly nodes: import("@angular/core").InputSignal<readonly SdFileExplorerTreeNode[]>;
|
|
11
|
+
/** Accessible name of the tree. */
|
|
12
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
13
|
+
/** A node was activated (click, Enter, Space). */
|
|
14
|
+
readonly select: import("@angular/core").OutputEmitterRef<SdFileExplorerTreeNode>;
|
|
15
|
+
/** Expand / collapse requested. */
|
|
16
|
+
readonly toggle: import("@angular/core").OutputEmitterRef<SdFileExplorerTreeNode>;
|
|
17
|
+
/** Retry loading the children of a node whose listing failed. */
|
|
18
|
+
readonly retry: import("@angular/core").OutputEmitterRef<SdFileExplorerTreeNode>;
|
|
19
|
+
protected readonly focusedKey: import("@angular/core").WritableSignal<string | null>;
|
|
20
|
+
protected readonly retryLabel: import("@angular/core").Signal<string>;
|
|
21
|
+
/** Node owning the roving tabindex: the focused node if still visible, else the selected one. */
|
|
22
|
+
protected readonly activeKey: import("@angular/core").Signal<string>;
|
|
23
|
+
protected toggleLabel(node: SdFileExplorerTreeNode): string;
|
|
24
|
+
protected onToggle(event: Event, node: SdFileExplorerTreeNode): void;
|
|
25
|
+
protected onRetry(event: Event, node: SdFileExplorerTreeNode): void;
|
|
26
|
+
protected onKeydown(event: KeyboardEvent, index: number): void;
|
|
27
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<SdFileExplorerFolderTree, never>;
|
|
28
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<SdFileExplorerFolderTree, "sd-file-explorer-folder-tree", never, { "nodes": { "alias": "nodes"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "select": "select"; "toggle": "toggle"; "retry": "retry"; }, never, never, true, never>;
|
|
29
|
+
}
|
|
@@ -0,0 +1,34 @@
|
|
|
1
|
+
import type { SdFileExplorerView } from '../file-explorer.model';
|
|
2
|
+
import type { SdFileExplorerItemView } from '../file-explorer.view-model';
|
|
3
|
+
import * as i0 from "@angular/core";
|
|
4
|
+
/**
|
|
5
|
+
* Items of the current folder (or search results) as a list or a grid (internal).
|
|
6
|
+
* Rows and cards are focusable; `Enter` / `Space` activate them like a click.
|
|
7
|
+
*/
|
|
8
|
+
export declare class SdFileExplorerItemList {
|
|
9
|
+
/** Items to render, already formatted. */
|
|
10
|
+
readonly items: import("@angular/core").InputSignal<readonly SdFileExplorerItemView[]>;
|
|
11
|
+
/** `list` or `grid`. */
|
|
12
|
+
readonly view: import("@angular/core").InputSignal<SdFileExplorerView>;
|
|
13
|
+
/** Show download buttons for files. */
|
|
14
|
+
readonly canDownload: import("@angular/core").InputSignal<boolean>;
|
|
15
|
+
/** Show share buttons for files. */
|
|
16
|
+
readonly canShare: import("@angular/core").InputSignal<boolean>;
|
|
17
|
+
/** Narrow layout: hides the modified column. */
|
|
18
|
+
readonly compact: import("@angular/core").InputSignal<boolean>;
|
|
19
|
+
/** Id of the file currently shown in the preview panel. */
|
|
20
|
+
readonly activeId: import("@angular/core").InputSignal<string | null>;
|
|
21
|
+
/** Accessible name of the list. */
|
|
22
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
23
|
+
/** Row / card activated. */
|
|
24
|
+
readonly activate: import("@angular/core").OutputEmitterRef<SdFileExplorerItemView>;
|
|
25
|
+
/** Download button pressed. */
|
|
26
|
+
readonly download: import("@angular/core").OutputEmitterRef<SdFileExplorerItemView>;
|
|
27
|
+
/** Share button pressed. */
|
|
28
|
+
readonly share: import("@angular/core").OutputEmitterRef<SdFileExplorerItemView>;
|
|
29
|
+
/** Width of the row action column: one 32 px icon button per enabled action. */
|
|
30
|
+
protected readonly actionsWidth: import("@angular/core").Signal<string | null>;
|
|
31
|
+
protected onKeydown(event: KeyboardEvent, view: SdFileExplorerItemView): void;
|
|
32
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<SdFileExplorerItemList, never>;
|
|
33
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<SdFileExplorerItemList, "sd-file-explorer-item-list", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "view": { "alias": "view"; "required": false; "isSignal": true; }; "canDownload": { "alias": "canDownload"; "required": false; "isSignal": true; }; "canShare": { "alias": "canShare"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "activeId": { "alias": "activeId"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "activate": "activate"; "download": "download"; "share": "share"; }, never, never, true, never>;
|
|
34
|
+
}
|
|
@@ -0,0 +1,52 @@
|
|
|
1
|
+
import { Type } from '@angular/core';
|
|
2
|
+
import { SdSideDrawer } from '@sdcorejs/angular/components/side-drawer';
|
|
3
|
+
import type { SdFileExplorerItemView, SdFileExplorerMetaRow, SdFileExplorerPreviewState } from '../file-explorer.view-model';
|
|
4
|
+
import * as i0 from "@angular/core";
|
|
5
|
+
/**
|
|
6
|
+
* File detail of the explorer (internal): an `<sd-side-drawer>` opened in the explorer's item area (right of the
|
|
7
|
+
* folder tree, below the header) through the drawer's `container` input, with the preview stage and metadata in its
|
|
8
|
+
* body and share / download in its footer.
|
|
9
|
+
*
|
|
10
|
+
* The explorer owns the open file: a non-null `view` opens the drawer, `null` closes it. When the user closes
|
|
11
|
+
* the drawer (close button, `Escape`, backdrop) the panel emits `close`.
|
|
12
|
+
*
|
|
13
|
+
* PDFs render with `<sd-preview-pdf>`, imported on demand so the PDF.js bundle is only fetched the first
|
|
14
|
+
* time a PDF is previewed.
|
|
15
|
+
*/
|
|
16
|
+
export declare class SdFileExplorerPreviewPanel {
|
|
17
|
+
#private;
|
|
18
|
+
/** File shown in the drawer; `null` closes the drawer. */
|
|
19
|
+
readonly view: import("@angular/core").InputSignal<SdFileExplorerItemView | null>;
|
|
20
|
+
/** What the stage renders. */
|
|
21
|
+
readonly state: import("@angular/core").InputSignal<SdFileExplorerPreviewState>;
|
|
22
|
+
/** Metadata rows (name, type, size, modified). */
|
|
23
|
+
readonly meta: import("@angular/core").InputSignal<readonly SdFileExplorerMetaRow[]>;
|
|
24
|
+
/** Show the download button. */
|
|
25
|
+
readonly canDownload: import("@angular/core").InputSignal<boolean>;
|
|
26
|
+
/** Show the share button. */
|
|
27
|
+
readonly canShare: import("@angular/core").InputSignal<boolean>;
|
|
28
|
+
/** Element the drawer opens inside: the explorer's item area, right of the folder tree. */
|
|
29
|
+
readonly container: import("@angular/core").InputSignal<HTMLElement | null>;
|
|
30
|
+
/** E2E scope of the detail content and its buttons. */
|
|
31
|
+
readonly autoId: import("@angular/core").InputSignal<string | undefined>;
|
|
32
|
+
/** The user closed the drawer (close button, `Escape` or backdrop). */
|
|
33
|
+
readonly close: import("@angular/core").OutputEmitterRef<void>;
|
|
34
|
+
/** Download button pressed. */
|
|
35
|
+
readonly download: import("@angular/core").OutputEmitterRef<void>;
|
|
36
|
+
/** Share button pressed. */
|
|
37
|
+
readonly share: import("@angular/core").OutputEmitterRef<void>;
|
|
38
|
+
/** Retry button of the error state pressed. */
|
|
39
|
+
readonly retry: import("@angular/core").OutputEmitterRef<void>;
|
|
40
|
+
/** The `<img>` failed to load. */
|
|
41
|
+
readonly imageError: import("@angular/core").OutputEmitterRef<void>;
|
|
42
|
+
protected readonly drawer: import("@angular/core").Signal<SdSideDrawer | undefined>;
|
|
43
|
+
protected readonly drawerTitle: import("@angular/core").Signal<string>;
|
|
44
|
+
protected readonly drawerAutoId: import("@angular/core").Signal<string | undefined>;
|
|
45
|
+
protected readonly pdfComponent: import("@angular/core").WritableSignal<Type<unknown> | null>;
|
|
46
|
+
protected readonly pdfFailed: import("@angular/core").WritableSignal<boolean>;
|
|
47
|
+
protected readonly pdfInputs: import("@angular/core").Signal<Record<string, unknown>>;
|
|
48
|
+
constructor();
|
|
49
|
+
protected onDrawerClosed(): void;
|
|
50
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<SdFileExplorerPreviewPanel, never>;
|
|
51
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<SdFileExplorerPreviewPanel, "sd-file-explorer-preview-panel", never, { "view": { "alias": "view"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": true; "isSignal": true; }; "meta": { "alias": "meta"; "required": false; "isSignal": true; }; "canDownload": { "alias": "canDownload"; "required": false; "isSignal": true; }; "canShare": { "alias": "canShare"; "required": false; "isSignal": true; }; "container": { "alias": "container"; "required": false; "isSignal": true; }; "autoId": { "alias": "autoId"; "required": false; "isSignal": true; }; }, { "close": "close"; "download": "download"; "share": "share"; "retry": "retry"; "imageError": "imageError"; }, never, never, true, never>;
|
|
52
|
+
}
|
|
@@ -0,0 +1,29 @@
|
|
|
1
|
+
import type { SdFileExplorerTransferView } from '../file-explorer.view-model';
|
|
2
|
+
import * as i0 from "@angular/core";
|
|
3
|
+
/**
|
|
4
|
+
* Transfer queue docked at the bottom of the explorer (internal). Shows one card per upload / download with
|
|
5
|
+
* its status, a progress bar and the cancel / retry / dismiss actions allowed by its state.
|
|
6
|
+
*/
|
|
7
|
+
export declare class SdFileExplorerTransferPanel {
|
|
8
|
+
/** Cards to render, newest last. */
|
|
9
|
+
readonly transfers: import("@angular/core").InputSignal<readonly SdFileExplorerTransferView[]>;
|
|
10
|
+
/** Header text ("Transfers · 2 items"). */
|
|
11
|
+
readonly title: import("@angular/core").InputSignal<string>;
|
|
12
|
+
/** Hide the cards, keep the header. */
|
|
13
|
+
readonly collapsed: import("@angular/core").InputSignal<boolean>;
|
|
14
|
+
/** Show the "Clear finished" button. */
|
|
15
|
+
readonly canClear: import("@angular/core").InputSignal<boolean>;
|
|
16
|
+
/** Narrow layout: "Clear finished" becomes an icon button so the header stays on one line. */
|
|
17
|
+
readonly compact: import("@angular/core").InputSignal<boolean>;
|
|
18
|
+
/** E2E scope of the panel. */
|
|
19
|
+
readonly autoId: import("@angular/core").InputSignal<string | undefined>;
|
|
20
|
+
readonly toggleCollapsed: import("@angular/core").OutputEmitterRef<void>;
|
|
21
|
+
readonly clear: import("@angular/core").OutputEmitterRef<void>;
|
|
22
|
+
readonly cancel: import("@angular/core").OutputEmitterRef<string>;
|
|
23
|
+
readonly retry: import("@angular/core").OutputEmitterRef<string>;
|
|
24
|
+
readonly dismiss: import("@angular/core").OutputEmitterRef<string>;
|
|
25
|
+
protected readonly titleId: string;
|
|
26
|
+
protected readonly listId: string;
|
|
27
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<SdFileExplorerTransferPanel, never>;
|
|
28
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<SdFileExplorerTransferPanel, "sd-file-explorer-transfer-panel", never, { "transfers": { "alias": "transfers"; "required": true; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "canClear": { "alias": "canClear"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "autoId": { "alias": "autoId"; "required": false; "isSignal": true; }; }, { "toggleCollapsed": "toggleCollapsed"; "clear": "clear"; "cancel": "cancel"; "retry": "retry"; "dismiss": "dismiss"; }, never, never, true, never>;
|
|
29
|
+
}
|
|
@@ -0,0 +1,8 @@
|
|
|
1
|
+
/** Name of a built-in SdFileExplorer file-type icon. */
|
|
2
|
+
export type SdFileExplorerIconName = 'file-3d' | 'file-7z' | 'file-ai' | 'file-app' | 'file-archive' | 'file-audio' | 'file-book' | 'file-code' | 'file-css' | 'file-csv' | 'file-design' | 'file-document' | 'file-figma' | 'file-font' | 'file-generic' | 'file-gif' | 'file-html' | 'file-image' | 'file-jpg' | 'file-js' | 'file-json' | 'file-markdown' | 'file-mov' | 'file-mp3' | 'file-mp4' | 'file-pdf' | 'file-png' | 'file-presentation' | 'file-psd' | 'file-python' | 'file-rar' | 'file-spreadsheet' | 'file-sql' | 'file-svg' | 'file-tar' | 'file-text' | 'file-ts' | 'file-video' | 'file-wav' | 'file-webp' | 'file-xml' | 'file-yaml' | 'file-zip' | 'folder-closed' | 'folder-open';
|
|
3
|
+
/** Icon markup (64 × 64 viewBox), without title / ARIA / fixed size — rendered decoratively. */
|
|
4
|
+
export declare const SD_FILE_EXPLORER_ICON_SVGS: Readonly<Record<SdFileExplorerIconName, string>>;
|
|
5
|
+
/** Lower-case extension (including compound ones such as `tar.gz`) → icon. */
|
|
6
|
+
export declare const SD_FILE_EXPLORER_ICON_EXTENSIONS: Readonly<Record<string, SdFileExplorerIconName>>;
|
|
7
|
+
/** Exact MIME type, or a family prefix ending with `/`, → icon. Used when the extension is unknown. */
|
|
8
|
+
export declare const SD_FILE_EXPLORER_ICON_MIME: Readonly<Record<string, SdFileExplorerIconName>>;
|
|
@@ -0,0 +1,135 @@
|
|
|
1
|
+
import { ElementRef, Signal, WritableSignal } from '@angular/core';
|
|
2
|
+
import { SdBreadcrumbItem } from '@sdcorejs/angular/components/breadcrumb';
|
|
3
|
+
import type { SdFileExplorerItem, SdFileExplorerOpenEvent, SdFileExplorerOption, SdFileExplorerTransfer, SdFileExplorerView } from './file-explorer.model';
|
|
4
|
+
import type { SdFileExplorerContentState, SdFileExplorerItemView, SdFileExplorerMetaRow, SdFileExplorerPreviewState, SdFileExplorerShareFeedback, SdFileExplorerShareState, SdFileExplorerTransferView, SdFileExplorerTreeNode } from './file-explorer.view-model';
|
|
5
|
+
import * as i0 from "@angular/core";
|
|
6
|
+
/**
|
|
7
|
+
* Google-Drive-like file browser: folder tree, breadcrumb, list / grid, search, file detail drawer, uploads with
|
|
8
|
+
* drag-and-drop, downloads and a transfer queue — all inside one element.
|
|
9
|
+
*
|
|
10
|
+
* Storage-agnostic: every read and write goes through the callbacks of `SdFileExplorerOption`.
|
|
11
|
+
*
|
|
12
|
+
* @example
|
|
13
|
+
* ```html
|
|
14
|
+
* <sd-file-explorer [option]="option" (open)="onOpen($event)" />
|
|
15
|
+
* ```
|
|
16
|
+
*/
|
|
17
|
+
export declare class SdFileExplorer {
|
|
18
|
+
#private;
|
|
19
|
+
/** Data callbacks and display settings. See `SdFileExplorerOption`. */
|
|
20
|
+
readonly option: import("@angular/core").InputSignal<SdFileExplorerOption>;
|
|
21
|
+
/**
|
|
22
|
+
* Emitted exactly once each time the user opens a file (click, `Enter` or `Space` on a file in the list,
|
|
23
|
+
* grid or search results), right before the detail drawer starts loading. Never emitted for folders.
|
|
24
|
+
*/
|
|
25
|
+
readonly open: import("@angular/core").OutputEmitterRef<SdFileExplorerOpenEvent>;
|
|
26
|
+
protected readonly view: WritableSignal<SdFileExplorerView>;
|
|
27
|
+
protected readonly keyword: WritableSignal<string>;
|
|
28
|
+
protected readonly previewState: WritableSignal<SdFileExplorerPreviewState>;
|
|
29
|
+
protected readonly transfersCollapsed: WritableSignal<boolean>;
|
|
30
|
+
protected readonly sidebarOpen: WritableSignal<boolean>;
|
|
31
|
+
protected readonly dragActive: WritableSignal<boolean>;
|
|
32
|
+
protected readonly folderDialogOpen: WritableSignal<boolean>;
|
|
33
|
+
protected readonly folderName: WritableSignal<string>;
|
|
34
|
+
protected readonly folderSubmitting: WritableSignal<boolean>;
|
|
35
|
+
protected readonly folderError: WritableSignal<string>;
|
|
36
|
+
/** File whose share dialog is open. */
|
|
37
|
+
protected readonly shareItem: WritableSignal<SdFileExplorerItem | null>;
|
|
38
|
+
protected readonly shareState: WritableSignal<SdFileExplorerShareState>;
|
|
39
|
+
/** Result of the last copy attempt: copied to the clipboard, or selected for a manual Ctrl+C. */
|
|
40
|
+
protected readonly shareFeedback: WritableSignal<SdFileExplorerShareFeedback>;
|
|
41
|
+
/**
|
|
42
|
+
* Uploads and downloads started in this explorer, oldest first. Read-only; use it for example to warn
|
|
43
|
+
* before leaving the page while `status` is `queued`, `preparing` or `transferring`.
|
|
44
|
+
*/
|
|
45
|
+
readonly transfers: Signal<readonly SdFileExplorerTransfer[]>;
|
|
46
|
+
protected readonly searchInput: Signal<ElementRef<HTMLInputElement> | undefined>;
|
|
47
|
+
protected readonly folderInput: Signal<ElementRef<HTMLInputElement> | undefined>;
|
|
48
|
+
protected readonly newFolderButton: Signal<ElementRef<HTMLElement> | undefined>;
|
|
49
|
+
protected readonly copyButton: Signal<ElementRef<HTMLElement> | undefined>;
|
|
50
|
+
protected readonly shareInput: Signal<ElementRef<HTMLInputElement> | undefined>;
|
|
51
|
+
protected readonly shareDialog: Signal<ElementRef<HTMLElement> | undefined>;
|
|
52
|
+
protected readonly sidebar: Signal<ElementRef<HTMLElement> | undefined>;
|
|
53
|
+
protected readonly instanceId: string;
|
|
54
|
+
protected readonly compact: Signal<boolean>;
|
|
55
|
+
readonly autoId: Signal<string | undefined>;
|
|
56
|
+
protected readonly locale: Signal<string>;
|
|
57
|
+
protected readonly rootLabel: Signal<string>;
|
|
58
|
+
protected readonly canUpload: Signal<boolean>;
|
|
59
|
+
protected readonly canDownload: Signal<boolean>;
|
|
60
|
+
protected readonly canCreateFolder: Signal<boolean>;
|
|
61
|
+
protected readonly canShare: Signal<boolean>;
|
|
62
|
+
protected readonly currentName: Signal<string>;
|
|
63
|
+
protected readonly searching: Signal<boolean>;
|
|
64
|
+
protected readonly itemViews: Signal<readonly SdFileExplorerItemView[]>;
|
|
65
|
+
protected readonly contentState: Signal<SdFileExplorerContentState>;
|
|
66
|
+
protected readonly refreshing: Signal<boolean>;
|
|
67
|
+
protected readonly errorMessage: Signal<string>;
|
|
68
|
+
protected readonly heading: Signal<string>;
|
|
69
|
+
protected readonly itemCountLabel: Signal<string>;
|
|
70
|
+
protected readonly emptyTitle: Signal<string>;
|
|
71
|
+
protected readonly emptyMessage: Signal<string>;
|
|
72
|
+
protected readonly dropTitle: Signal<string>;
|
|
73
|
+
protected readonly shareTitle: Signal<string>;
|
|
74
|
+
protected readonly shareFeedbackLabel: Signal<string>;
|
|
75
|
+
protected readonly folderDialogTitle: Signal<string>;
|
|
76
|
+
/** Breadcrumb trail plus the folder each entry navigates to. */
|
|
77
|
+
protected readonly breadcrumb: Signal<{
|
|
78
|
+
items: SdBreadcrumbItem[];
|
|
79
|
+
targets: Map<SdBreadcrumbItem, SdFileExplorerItem | null>;
|
|
80
|
+
}>;
|
|
81
|
+
protected readonly treeNodes: Signal<readonly SdFileExplorerTreeNode[]>;
|
|
82
|
+
protected readonly previewView: Signal<SdFileExplorerItemView | null>;
|
|
83
|
+
protected readonly previewMeta: Signal<readonly SdFileExplorerMetaRow[]>;
|
|
84
|
+
protected readonly transferViews: Signal<readonly SdFileExplorerTransferView[]>;
|
|
85
|
+
protected readonly transfersTitle: Signal<string>;
|
|
86
|
+
protected readonly canClearTransfers: Signal<boolean>;
|
|
87
|
+
constructor();
|
|
88
|
+
/**
|
|
89
|
+
* Lists the current folder again and drops the cached children of folders that are neither open in the
|
|
90
|
+
* tree nor on the current path. Re-runs the active search, if any.
|
|
91
|
+
*/
|
|
92
|
+
reload(): void;
|
|
93
|
+
protected navigate(folder: SdFileExplorerItem | null): void;
|
|
94
|
+
protected onBreadcrumb(entry: SdBreadcrumbItem): void;
|
|
95
|
+
protected onTreeSelect(node: SdFileExplorerTreeNode): void;
|
|
96
|
+
protected onTreeToggle(node: SdFileExplorerTreeNode): void;
|
|
97
|
+
protected onTreeRetry(node: SdFileExplorerTreeNode): void;
|
|
98
|
+
protected retryContent(): void;
|
|
99
|
+
protected toggleSidebar(): void;
|
|
100
|
+
protected setView(view: SdFileExplorerView): void;
|
|
101
|
+
protected onActivate(view: SdFileExplorerItemView): void;
|
|
102
|
+
protected openFile(item: SdFileExplorerItem): void;
|
|
103
|
+
/**
|
|
104
|
+
* Closes the detail drawer. Focus goes back to the row / card that opened it: `sd-side-drawer` restores the
|
|
105
|
+
* previously focused element when its focus trap closes.
|
|
106
|
+
*/
|
|
107
|
+
protected closePreview(): void;
|
|
108
|
+
protected retryPreview(): void;
|
|
109
|
+
protected onPreviewImageError(): void;
|
|
110
|
+
protected downloadItem(item: SdFileExplorerItem): void;
|
|
111
|
+
protected downloadPreview(): void;
|
|
112
|
+
protected sharePreview(): void;
|
|
113
|
+
protected onKeywordInput(value: string): void;
|
|
114
|
+
protected clearSearch(): void;
|
|
115
|
+
protected onFilesPicked(input: HTMLInputElement): void;
|
|
116
|
+
protected uploadFiles(files: readonly File[]): void;
|
|
117
|
+
protected onDragEnter(event: DragEvent): void;
|
|
118
|
+
protected onDragOver(event: DragEvent): void;
|
|
119
|
+
protected onDragLeave(): void;
|
|
120
|
+
protected onDrop(event: DragEvent): void;
|
|
121
|
+
protected cancelTransfer(id: string): void;
|
|
122
|
+
protected retryTransfer(id: string): void;
|
|
123
|
+
protected dismissTransfer(id: string): void;
|
|
124
|
+
protected clearFinishedTransfers(): void;
|
|
125
|
+
protected openFolderDialog(): void;
|
|
126
|
+
protected closeFolderDialog(): void;
|
|
127
|
+
protected openShare(item: SdFileExplorerItem): void;
|
|
128
|
+
protected retryShare(): void;
|
|
129
|
+
protected closeShare(): void;
|
|
130
|
+
protected copyShareLink(): Promise<void>;
|
|
131
|
+
protected submitFolder(event: Event): Promise<void>;
|
|
132
|
+
protected onEscape(event: Event): void;
|
|
133
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<SdFileExplorer, never>;
|
|
134
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<SdFileExplorer, "sd-file-explorer", never, { "option": { "alias": "option"; "required": true; "isSignal": true; }; }, { "open": "open"; }, never, never, true, never>;
|
|
135
|
+
}
|
|
@@ -0,0 +1,268 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Kind of an explorer entry. Folders can be opened and listed; files can be previewed and downloaded.
|
|
3
|
+
*/
|
|
4
|
+
export type SdFileExplorerItemKind = 'folder' | 'file';
|
|
5
|
+
/**
|
|
6
|
+
* One file or folder shown by `<sd-file-explorer>`.
|
|
7
|
+
*
|
|
8
|
+
* The explorer never talks to a storage API itself: every item comes from `SdFileExplorerOption.list`
|
|
9
|
+
* (or `search`), so map your own DTO into this shape inside the callback.
|
|
10
|
+
*
|
|
11
|
+
* @example
|
|
12
|
+
* ```ts
|
|
13
|
+
* const item: SdFileExplorerItem = {
|
|
14
|
+
* id: 'f-42',
|
|
15
|
+
* parentId: 'folder-7', // null = item sits in the root folder
|
|
16
|
+
* name: 'Contract.pdf',
|
|
17
|
+
* kind: 'file',
|
|
18
|
+
* mimeType: 'application/pdf',
|
|
19
|
+
* size: 2_516_582,
|
|
20
|
+
* modifiedAt: '2026-09-21T08:30:00Z',
|
|
21
|
+
* };
|
|
22
|
+
* ```
|
|
23
|
+
*/
|
|
24
|
+
export interface SdFileExplorerItem {
|
|
25
|
+
/** Stable id, unique across the whole tree. Used for tracking, navigation and `autoId` suffixes. */
|
|
26
|
+
id: string;
|
|
27
|
+
/** Id of the containing folder, or `null` when the item sits in the root folder. */
|
|
28
|
+
parentId: string | null;
|
|
29
|
+
/** Display name, including the extension for files. */
|
|
30
|
+
name: string;
|
|
31
|
+
/** `'folder'` or `'file'`. */
|
|
32
|
+
kind: SdFileExplorerItemKind;
|
|
33
|
+
/**
|
|
34
|
+
* MIME type such as `application/pdf` or `image/png`. Drives the type label and the preview renderer, falling
|
|
35
|
+
* back to the file extension in `name` when omitted. The file-type icon prefers the extension and uses the MIME
|
|
36
|
+
* type only when the extension is unknown.
|
|
37
|
+
*/
|
|
38
|
+
mimeType?: string;
|
|
39
|
+
/** Size in bytes. Shown for files only; the column shows a dash when omitted. */
|
|
40
|
+
size?: number;
|
|
41
|
+
/** Last modification time (a `Date`, an ISO string or epoch milliseconds). The column shows a dash when omitted. */
|
|
42
|
+
modifiedAt?: Date | string | number;
|
|
43
|
+
/**
|
|
44
|
+
* Folders only. Set `false` for a folder known to contain no sub-folders so the tree hides its expander.
|
|
45
|
+
* Leave `undefined` when unknown; the tree then shows the expander until the folder has been listed.
|
|
46
|
+
*/
|
|
47
|
+
hasChildren?: boolean;
|
|
48
|
+
/** Image URL shown on the grid card instead of the file-type icon. Caller-owned: the explorer never revokes it. */
|
|
49
|
+
thumbnailUrl?: string;
|
|
50
|
+
}
|
|
51
|
+
/** Arguments of `SdFileExplorerOption.list`. */
|
|
52
|
+
export interface SdFileExplorerListArgs {
|
|
53
|
+
/** Folder whose direct children are requested; `null` is the root folder. */
|
|
54
|
+
parentId: string | null;
|
|
55
|
+
/**
|
|
56
|
+
* Aborted when the result is no longer needed: the same folder is listed again (`reload()`, a finished upload),
|
|
57
|
+
* the `list` callback is replaced, or the explorer is destroyed. Navigating away does not abort — the result
|
|
58
|
+
* is cached for the next visit.
|
|
59
|
+
*/
|
|
60
|
+
signal: AbortSignal;
|
|
61
|
+
}
|
|
62
|
+
/** Arguments of `SdFileExplorerOption.search`. */
|
|
63
|
+
export interface SdFileExplorerSearchArgs {
|
|
64
|
+
/** Folder the user is currently viewing; `null` is the root folder. */
|
|
65
|
+
parentId: string | null;
|
|
66
|
+
/** Trimmed, non-empty keyword typed by the user. */
|
|
67
|
+
keyword: string;
|
|
68
|
+
/** Aborted when a newer keyword supersedes this one, the search is cleared or the user navigates away. */
|
|
69
|
+
signal: AbortSignal;
|
|
70
|
+
}
|
|
71
|
+
/** Arguments of `SdFileExplorerOption.preview`. */
|
|
72
|
+
export interface SdFileExplorerPreviewArgs {
|
|
73
|
+
/** File being previewed. */
|
|
74
|
+
item: SdFileExplorerItem;
|
|
75
|
+
/** Aborted when the detail drawer is closed or another file is opened before this one resolves. */
|
|
76
|
+
signal: AbortSignal;
|
|
77
|
+
}
|
|
78
|
+
/**
|
|
79
|
+
* Content returned by `SdFileExplorerOption.preview`.
|
|
80
|
+
*
|
|
81
|
+
* - `string`: a URL. Caller-owned — the explorer uses it as-is and never revokes it.
|
|
82
|
+
* - `Blob` / `File`: the explorer creates an object URL when needed and revokes it when the preview closes,
|
|
83
|
+
* another file is opened, or the explorer is destroyed.
|
|
84
|
+
*/
|
|
85
|
+
export type SdFileExplorerPreviewSource = string | Blob;
|
|
86
|
+
/**
|
|
87
|
+
* Progress reporter handed to `upload` and `download`.
|
|
88
|
+
*
|
|
89
|
+
* Call it with the bytes transferred so far and, when known, the total size. The first call moves the
|
|
90
|
+
* transfer from `preparing` to `transferring`. A percentage is displayed only when `total` is a positive
|
|
91
|
+
* number; without it the progress bar stays indeterminate — the explorer never invents a percentage.
|
|
92
|
+
*/
|
|
93
|
+
export type SdFileExplorerProgressReporter = (loaded: number, total?: number) => void;
|
|
94
|
+
/** Arguments shared by `upload` and `download`. */
|
|
95
|
+
export interface SdFileExplorerTransferArgs {
|
|
96
|
+
/** Report transfer progress. Optional to call; calls after the transfer ended are ignored. */
|
|
97
|
+
progress: SdFileExplorerProgressReporter;
|
|
98
|
+
/**
|
|
99
|
+
* Aborted when the user cancels the transfer or the explorer is destroyed. Pass it to `fetch`/`HttpClient`
|
|
100
|
+
* (or abort your XHR) so cancelling really stops the network request.
|
|
101
|
+
*/
|
|
102
|
+
signal: AbortSignal;
|
|
103
|
+
}
|
|
104
|
+
/** Arguments of `SdFileExplorerOption.upload`. */
|
|
105
|
+
export interface SdFileExplorerUploadArgs extends SdFileExplorerTransferArgs {
|
|
106
|
+
/** File picked through the upload button or dropped onto the explorer. */
|
|
107
|
+
file: File;
|
|
108
|
+
/** Destination folder (the folder being viewed when the upload started); `null` is the root folder. */
|
|
109
|
+
parentId: string | null;
|
|
110
|
+
}
|
|
111
|
+
/** Arguments of `SdFileExplorerOption.download`. */
|
|
112
|
+
export interface SdFileExplorerDownloadArgs extends SdFileExplorerTransferArgs {
|
|
113
|
+
/** File to download. */
|
|
114
|
+
item: SdFileExplorerItem;
|
|
115
|
+
}
|
|
116
|
+
/** Arguments of `SdFileExplorerOption.share`. */
|
|
117
|
+
export interface SdFileExplorerShareArgs {
|
|
118
|
+
/** File to share. */
|
|
119
|
+
item: SdFileExplorerItem;
|
|
120
|
+
/** Aborted when the user closes the share dialog before the link is ready, or the explorer is destroyed. */
|
|
121
|
+
signal: AbortSignal;
|
|
122
|
+
}
|
|
123
|
+
/** Arguments of `SdFileExplorerOption.createFolder`. */
|
|
124
|
+
export interface SdFileExplorerCreateFolderArgs {
|
|
125
|
+
/** Folder that receives the new folder (the folder being viewed); `null` is the root folder. */
|
|
126
|
+
parentId: string | null;
|
|
127
|
+
/** Trimmed, non-empty name typed by the user. */
|
|
128
|
+
name: string;
|
|
129
|
+
}
|
|
130
|
+
/** Layout of the item area. */
|
|
131
|
+
export type SdFileExplorerView = 'list' | 'grid';
|
|
132
|
+
/**
|
|
133
|
+
* Configuration of `<sd-file-explorer>`.
|
|
134
|
+
*
|
|
135
|
+
* Only `list` is required. Every other callback is optional and switches its UI on: without `upload` there is
|
|
136
|
+
* no upload button and no drop zone, without `createFolder` there is no "New folder" button, without `download`
|
|
137
|
+
* or `share` there are no download or share buttons. Callbacks may return a value or a `Promise`; a thrown error or a rejected
|
|
138
|
+
* promise is shown as an error state (listing, preview) or a failed transfer (upload, download).
|
|
139
|
+
*
|
|
140
|
+
* The explorer is storage-agnostic: it does not know about HTTP endpoints, presigned URLs or providers.
|
|
141
|
+
* Keep that knowledge inside the callbacks.
|
|
142
|
+
*
|
|
143
|
+
* @example
|
|
144
|
+
* ```ts
|
|
145
|
+
* readonly option: SdFileExplorerOption = {
|
|
146
|
+
* title: 'My files',
|
|
147
|
+
* list: ({ parentId, signal }) => firstValueFrom(this.api.children(parentId, { signal })),
|
|
148
|
+
* search: ({ parentId, keyword }) => firstValueFrom(this.api.search(parentId, keyword)),
|
|
149
|
+
* preview: ({ item }) => this.api.previewUrl(item.id), // string URL or Blob
|
|
150
|
+
* download: ({ item, progress, signal }) => this.api.downloadBlob(item.id, progress, signal), // Blob
|
|
151
|
+
* share: ({ item }) => firstValueFrom(this.api.createShareLink(item.id)), // URL string
|
|
152
|
+
* upload: ({ file, parentId, progress, signal }) => this.api.upload(file, parentId, progress, signal),
|
|
153
|
+
* createFolder: ({ parentId, name }) => firstValueFrom(this.api.createFolder(parentId, name)),
|
|
154
|
+
* };
|
|
155
|
+
* ```
|
|
156
|
+
*/
|
|
157
|
+
export interface SdFileExplorerOption {
|
|
158
|
+
/**
|
|
159
|
+
* Returns the direct children (files and folders) of a folder. Required.
|
|
160
|
+
*
|
|
161
|
+
* Called lazily: once per folder when it is first opened or expanded in the tree, then cached until
|
|
162
|
+
* `reload()` or a successful upload / folder creation in that folder. `parentId` is `null` for the root.
|
|
163
|
+
*/
|
|
164
|
+
list: (args: SdFileExplorerListArgs) => SdFileExplorerItem[] | Promise<SdFileExplorerItem[]>;
|
|
165
|
+
/**
|
|
166
|
+
* Server-side search inside the current folder. Called 300 ms after the user stops typing, and only for a
|
|
167
|
+
* non-empty keyword; stale requests are aborted and their results ignored.
|
|
168
|
+
*
|
|
169
|
+
* When omitted, the search box filters the already loaded children of the current folder by name
|
|
170
|
+
* (case- and Vietnamese-accent-insensitive) without calling any callback.
|
|
171
|
+
*/
|
|
172
|
+
search?: (args: SdFileExplorerSearchArgs) => SdFileExplorerItem[] | Promise<SdFileExplorerItem[]>;
|
|
173
|
+
/**
|
|
174
|
+
* Resolves the content shown in the detail drawer when a file is opened.
|
|
175
|
+
*
|
|
176
|
+
* Images render as `<img>`; PDFs render with `<sd-preview-pdf>` (loaded on demand, so consumers that never
|
|
177
|
+
* preview a PDF do not download PDF.js). Return `null`/`undefined` — or omit the callback — to show the
|
|
178
|
+
* "no preview" fallback. Other formats always show the fallback with a download button.
|
|
179
|
+
*/
|
|
180
|
+
preview?: (args: SdFileExplorerPreviewArgs) => SdFileExplorerPreviewSource | null | undefined | Promise<SdFileExplorerPreviewSource | null | undefined>;
|
|
181
|
+
/**
|
|
182
|
+
* Downloads a file. Enables the download buttons in list, grid and preview.
|
|
183
|
+
*
|
|
184
|
+
* - Return a `Blob`: the explorer saves it under `item.name`. Call `progress` while fetching to show a percentage.
|
|
185
|
+
* - Return nothing: you handed the download to the browser yourself (for example `window.open(url)` or an
|
|
186
|
+
* anchor with `download`). The transfer is then marked "handed to the browser" without a fake percentage.
|
|
187
|
+
*/
|
|
188
|
+
download?: (args: SdFileExplorerDownloadArgs) => Blob | void | Promise<Blob | void>;
|
|
189
|
+
/**
|
|
190
|
+
* Creates a shareable link for a file and returns its URL. Enables the "Share" buttons (list rows and
|
|
191
|
+
* detail drawer).
|
|
192
|
+
*
|
|
193
|
+
* The explorer opens a dialog that shows the link with a "Copy link" button — copying happens on that
|
|
194
|
+
* explicit click, so it works even when the callback takes a while. Throw (or reject) to show the error
|
|
195
|
+
* `message` with a retry button. Expiry, permissions or audience stay in your API.
|
|
196
|
+
*/
|
|
197
|
+
share?: (args: SdFileExplorerShareArgs) => string | Promise<string>;
|
|
198
|
+
/**
|
|
199
|
+
* Uploads one file into `parentId`. Enables the upload button and drag-and-drop.
|
|
200
|
+
*
|
|
201
|
+
* Called once per file, at most 3 files at a time; extra files wait in the queue. After success the
|
|
202
|
+
* destination folder is listed again. Throw (or reject) to mark the transfer as failed — the error `message`
|
|
203
|
+
* is shown as the failure reason and the user can retry.
|
|
204
|
+
*/
|
|
205
|
+
upload?: (args: SdFileExplorerUploadArgs) => SdFileExplorerItem | void | Promise<SdFileExplorerItem | void>;
|
|
206
|
+
/**
|
|
207
|
+
* Creates a folder inside the current folder. Enables the "New folder" button.
|
|
208
|
+
* After success the current folder is listed again. Throw (or reject) to keep the dialog open with the error.
|
|
209
|
+
*/
|
|
210
|
+
createFolder?: (args: SdFileExplorerCreateFolderArgs) => SdFileExplorerItem | void | Promise<SdFileExplorerItem | void>;
|
|
211
|
+
/** Heading shown in the explorer header. When omitted the header shows only search and upload. */
|
|
212
|
+
title?: string;
|
|
213
|
+
/** Secondary line under `title`. Ignored when `title` is omitted. */
|
|
214
|
+
description?: string;
|
|
215
|
+
/** Label of the root folder in the tree and breadcrumb. Defaults to the translated "All files". */
|
|
216
|
+
rootLabel?: string;
|
|
217
|
+
/** Initial layout of the item area. The user can switch afterwards. @defaultValue `'list'` */
|
|
218
|
+
defaultView?: SdFileExplorerView;
|
|
219
|
+
/** E2E scope. Produces `data-autoid="components-file-explorer-{autoId}"` and derived child ids. */
|
|
220
|
+
autoId?: string;
|
|
221
|
+
}
|
|
222
|
+
/**
|
|
223
|
+
* Payload of the `(open)` output.
|
|
224
|
+
*
|
|
225
|
+
* Emitted exactly once each time the user opens a file (click, `Enter` or `Space` on a file in the list,
|
|
226
|
+
* grid or search results). Not emitted for folders, which navigate instead, nor when the detail drawer
|
|
227
|
+
* re-renders or reloads.
|
|
228
|
+
*/
|
|
229
|
+
export interface SdFileExplorerOpenEvent {
|
|
230
|
+
/** The file that was opened. */
|
|
231
|
+
item: SdFileExplorerItem;
|
|
232
|
+
/** Folders from the root (excluded) down to the folder being viewed when the file was opened. */
|
|
233
|
+
path: readonly SdFileExplorerItem[];
|
|
234
|
+
}
|
|
235
|
+
/** Direction of a transfer shown in the transfer panel. */
|
|
236
|
+
export type SdFileExplorerTransferDirection = 'upload' | 'download';
|
|
237
|
+
/**
|
|
238
|
+
* Lifecycle of a transfer.
|
|
239
|
+
*
|
|
240
|
+
* - `queued`: waiting for a free upload slot (at most 3 uploads run at the same time).
|
|
241
|
+
* - `preparing`: the callback is running but has not reported progress yet (for example requesting a signed URL).
|
|
242
|
+
* - `transferring`: the callback reported progress at least once.
|
|
243
|
+
* - `done`: the callback resolved.
|
|
244
|
+
* - `error`: the callback threw or rejected; `error` holds the reason. The user can retry.
|
|
245
|
+
* - `cancelled`: the user cancelled; the `signal` passed to the callback was aborted. The user can retry.
|
|
246
|
+
*/
|
|
247
|
+
export type SdFileExplorerTransferStatus = 'queued' | 'preparing' | 'transferring' | 'done' | 'error' | 'cancelled';
|
|
248
|
+
/** Read-only snapshot of one upload or download, exposed through `SdFileExplorer.transfers`. */
|
|
249
|
+
export interface SdFileExplorerTransfer {
|
|
250
|
+
/** Internal id, unique within the explorer instance. */
|
|
251
|
+
readonly id: string;
|
|
252
|
+
/** `'upload'` or `'download'`. */
|
|
253
|
+
readonly direction: SdFileExplorerTransferDirection;
|
|
254
|
+
/** File name shown in the transfer panel. */
|
|
255
|
+
readonly name: string;
|
|
256
|
+
/** Current lifecycle state. */
|
|
257
|
+
readonly status: SdFileExplorerTransferStatus;
|
|
258
|
+
/** Bytes reported by the last `progress` call. */
|
|
259
|
+
readonly loaded?: number;
|
|
260
|
+
/** Total reported by the last `progress` call, when known. */
|
|
261
|
+
readonly total?: number;
|
|
262
|
+
/** 0–100, present only when the callback reported a positive `total`. Absent means indeterminate. */
|
|
263
|
+
readonly percent?: number;
|
|
264
|
+
/** Download finished by handing the file to the browser (the callback returned no `Blob`). */
|
|
265
|
+
readonly handedOff?: boolean;
|
|
266
|
+
/** Reason of the failure when `status` is `'error'`. */
|
|
267
|
+
readonly error?: unknown;
|
|
268
|
+
}
|