@brftech/filex-core 0.5.0 → 0.7.0

package/dist/index.d.ts

@@ -12,6 +12,46 @@ declare type __VLS_Props = {
     config: ExplorerConfig;
 };
 
+declare type __VLS_Props_10 = {
+    tabs: TabItem[];
+    activeId: string;
+    locale: LocaleCode;
+    /** false → the split toggle is hidden (narrow embeds). */
+    splitEnabled?: boolean;
+    /** true → the split toggle renders pressed (active tab has a pane). */
+    splitActive?: boolean;
+};
+
+declare type __VLS_Props_11 = {
+    api: FileApi;
+    /** Opening location, in the host's `currentPath` form. */
+    initialPath: string;
+    locale: LocaleCode;
+    /** Host's own qualify(): user path → wire `<adapter>://<rel>`. */
+    qualify: (p: string) => string;
+    /** Host's wire → user-path converter (multi-storage aware). */
+    toUser: (wire: string) => string;
+    /** Host's rootFloor clamp — keeps the pane inside the confine. */
+    clamp: (p: string) => string;
+    /** Label for the root crumb (adapter name / storage list). */
+    rootLabel: string;
+    /** rootFloor (user-path form, '' when unconfined) — trims crumbs. */
+    floor?: string;
+    /** Multi-storage mode: '' is the virtual drives root (no fetch). */
+    multiRoot?: boolean;
+    /** Synthesized storage rows for the virtual drives root. */
+    virtualRows?: () => FileNode[];
+    /** Active-panel highlight (keyboard target). */
+    active?: boolean;
+};
+
+declare type __VLS_Props_12 = {
+    open: boolean;
+    locale: LocaleCode;
+    /** True while the parent is creating the folder + uploading the marker. */
+    busy?: boolean;
+};
+
 declare type __VLS_Props_2 = {
     open: boolean;
     locale: LocaleCode;
@@ -30,6 +70,7 @@ declare type __VLS_Props_2 = {
     pdfSaveUrl?: string | null;
     /** Standalone full-screen viewer route — `?path=…&storage=…&type=…`. */
     viewerBaseUrl?: string | null;
+    newTabEnabled?: boolean;
     /** Drop the dialog chrome (backdrop tint, header bar, footer actions)
      *  so the viewer fills the full viewport. Used by the standalone
      *  /files/edit route where the browser tab IS the container — a
@@ -216,16 +257,122 @@ declare interface ContextAction {
     divider?: boolean;
 }
 
+/**
+ * Tiny per-explorer key ring: encrypted-folder root (wire path) → KEK.
+ * Lives ONLY in memory — "Kilitle" drops the entry, a reload drops all.
+ */
+export declare function createKeyRing(): {
+    get(root: string): CryptoKey | undefined;
+    set(root: string, kek: CryptoKey): void;
+    /** Drop one folder's key ("Kilitle"). */
+    lock(root: string): void;
+    has(root: string): boolean;
+    clear(): void;
+};
+
+/** Create a fresh folder marker for `password` (also returns the derived KEK). */
+export declare function createMarker(password: string, iterations?: number): Promise<{
+    marker: E2eMarker;
+    kek: CryptoKey;
+}>;
+
+/**
+ * Decrypt a 'filexe2e' blob with the folder KEK. Throws E2eDecryptError on
+ * a wrong key / tampered data, and a plain Error when the header is not an
+ * e2e file at all.
+ */
+export declare function decryptFile(kek: CryptoKey, data: ArrayBuffer): Promise<ArrayBuffer>;
+
 export declare const DEFAULT_THEME_ID = "default";
 
 declare type Density = 'comfortable' | 'compact';
 
+/**
+ * Derive the folder KEK from a password. Returns a NON-extractable
+ * AES-256-GCM CryptoKey — it can encrypt/decrypt but never be exported,
+ * so even a same-origin script can't read the raw key material back.
+ */
+export declare function deriveKek(password: string, salt: Uint8Array, iterations: number): Promise<CryptoKey>;
+
+export declare const E2E_DEFAULT_ITERATIONS = 600000;
+
+export declare const E2E_MAGIC = "filexe2e";
+
+/**
+ * e2ecrypto — client-side crypto for E2E-encrypted folders (wiring:e2).
+ *
+ * WebCrypto ONLY — zero dependencies. Design doc: docs/E2E-ENCRYPTION.md.
+ *
+ * Scheme (v1):
+ *   folder password ─PBKDF2-SHA256(600k iter, per-folder 16B salt)─▶ KEK (AES-256-GCM)
+ *   per-file random 32B DEK (AES-256-GCM) encrypts the content one-shot;
+ *   the DEK is wrapped with the KEK and stored in the file's own header.
+ *
+ * File layout ('filexe2e' magic, fixed 97-byte header):
+ *   [0..8)   magic  "filexe2e"
+ *   [8]      version 0x01
+ *   [9..21)  wrapIV  (12B)  — GCM IV of the DEK wrap
+ *   [21..69) wrappedDEK (48B = 32B DEK + 16B GCM tag)
+ *   [69..81) dataIV  (12B)  — GCM IV of the content
+ *   [81..97) reserved (zeros; v2 chunking/metadata)
+ *   [97..)   ciphertext (content + 16B GCM tag)
+ *
+ * Folder marker `.filex-e2e.json` at the encrypted-folder root:
+ *   { v:1, salt:<b64 16B>, iter:600000, verify:<b64 12B IV || GCM('filex-e2e-verify-v1')> }
+ *
+ * The KEK NEVER leaves memory — no storage of any kind. Password loss is
+ * data loss by design (no recovery path exists anywhere).
+ */
+export declare const E2E_MARKER_NAME = ".filex-e2e.json";
+
+/** MVP single-shot in-memory ceiling — larger uploads are refused with a warning. */
+export declare const E2E_MAX_FILE_BYTES: number;
+
+export declare const E2E_MIN_PASSWORD_LEN = 8;
+
+export declare const E2E_VERSION = 1;
+
+/** Thrown on wrong password / corrupted ciphertext (GCM tag mismatch). */
+export declare class E2eDecryptError extends Error {
+    constructor(msg?: string);
+}
+
+export declare type E2eKeyRing = ReturnType<typeof createKeyRing>;
+
+export declare interface E2eMarker {
+    v: number;
+    salt: string;
+    iter: number;
+    verify: string;
+}
+
 /** Current combo for an action ('' = unbound). */
 export declare function effectiveCombo(id: string): string;
 
 /** English UI strings. */
 export declare const en: Record<string, string>;
 
+export declare const EncryptedFolderModal: DefineComponent<__VLS_Props_12, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+close: () => any;
+submit: (payload: {
+name: string;
+password: string;
+}) => any;
+}, string, PublicProps, Readonly<__VLS_Props_12> & Readonly<{
+onClose?: (() => any) | undefined;
+onSubmit?: ((payload: {
+name: string;
+password: string;
+}) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+/**
+ * Encrypt `content` under the folder KEK: mints a fresh DEK, encrypts the
+ * content one-shot, wraps the DEK with the KEK and prepends the fixed
+ * 'filexe2e' header. Throws when content exceeds E2E_MAX_FILE_BYTES.
+ */
+export declare function encryptFile(kek: CryptoKey, content: ArrayBuffer): Promise<ArrayBuffer>;
+
 /**
  * Resolved endpoint map. `useFileApi` derives this once on construction
  * — components never need to think about config/apiBase precedence.
@@ -648,6 +795,82 @@ onRefresh?: (() => any) | undefined;
 }>, {
 focusSearch: () => Promise<void>;
 }, {}, {}, {}, {}> | null;
+splitPaneRef: CreateComponentPublicInstanceWithMixins<Readonly<{
+api: FileApi;
+initialPath: string;
+locale: LocaleCode;
+qualify: (p: string) => string;
+toUser: (wire: string) => string;
+clamp: (p: string) => string;
+rootLabel: string;
+floor?: string;
+multiRoot?: boolean;
+virtualRows?: () => FileNode[];
+active?: boolean;
+}> & Readonly<{
+onClose?: (() => any) | undefined;
+onNavigate?: ((path: string) => any) | undefined;
+onActivate?: (() => any) | undefined;
+"onOpen-tab"?: ((path: string) => any) | undefined;
+onTransfer?: ((p: {
+sources: string[];
+targetWire: string;
+originWire?: string;
+}) => any) | undefined;
+}>, {
+reload: () => Promise<void>;
+goUp: () => void;
+selectAll: () => void;
+openSelected: () => void;
+selectedNodes: () => FileNode[];
+getPath: () => string;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+close: () => any;
+navigate: (path: string) => any;
+activate: () => any;
+"open-tab": (path: string) => any;
+transfer: (p: {
+sources: string[];
+targetWire: string;
+originWire?: string;
+}) => any;
+}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
+P: {};
+B: {};
+D: {};
+C: {};
+M: {};
+Defaults: {};
+}, Readonly<{
+api: FileApi;
+initialPath: string;
+locale: LocaleCode;
+qualify: (p: string) => string;
+toUser: (wire: string) => string;
+clamp: (p: string) => string;
+rootLabel: string;
+floor?: string;
+multiRoot?: boolean;
+virtualRows?: () => FileNode[];
+active?: boolean;
+}> & Readonly<{
+onClose?: (() => any) | undefined;
+onNavigate?: ((path: string) => any) | undefined;
+onActivate?: (() => any) | undefined;
+"onOpen-tab"?: ((path: string) => any) | undefined;
+onTransfer?: ((p: {
+sources: string[];
+targetWire: string;
+originWire?: string;
+}) => any) | undefined;
+}>, {
+reload: () => Promise<void>;
+goUp: () => void;
+selectAll: () => void;
+openSelected: () => void;
+selectedNodes: () => FileNode[];
+getPath: () => string;
+}, {}, {}, {}, {}> | null;
 ctxRef: CreateComponentPublicInstanceWithMixins<Readonly<{
 locale: LocaleCode;
 actions: ContextAction[];
@@ -734,6 +957,7 @@ export declare interface FileNode {
      *  projectFileNodes emits it when a storage has RBAC on). '' / undefined =
      *  ACL not enforced. Used to gate edit/manage affordances client-side. */
     perm?: 'none' | 'viewer' | 'editor' | 'owner';
+    e2e?: boolean;
     /** Generic — any additional fields the backend wants to inline. */
     [k: string]: unknown;
 }
@@ -759,6 +983,8 @@ export declare function getHighlight(): unknown | null;
 /** Synchronous cached lookup — null if Monaco not yet ready or absent. */
 export declare function getMonaco(): unknown | null;
 
+declare function getPath(): string;
+
 /**
  * One hit from the dedicated files-search endpoint. The backend returns raw
  * node rows (`{results: [...]}`), so `path` is the IN-STORAGE relative path
@@ -785,6 +1011,8 @@ export declare interface GlobalSearchHit {
 
 export declare type GlobalSearchScope = 'name' | 'content' | 'all';
 
+declare function goUp(): void;
+
 /** A single ACL grant row (RBAC permissions panel). */
 declare interface Grant {
     id: number;
@@ -797,6 +1025,9 @@ declare interface Grant {
     inherited?: boolean;
 }
 
+/** True when the buffer starts with the 'filexe2e' magic. */
+export declare function hasMagic(buf: ArrayBuffer | Uint8Array): boolean;
+
 declare interface InviteResponse {
     mode: 'granted' | 'user_created' | 'shared';
     user_id?: number;
@@ -822,6 +1053,8 @@ export declare interface ManagerResponse {
     /** RBAC effective level for the current user on this directory ('' when ACL
      *  is not enforced on the storage). Gates the folder-level write actions. */
     perm?: 'none' | 'viewer' | 'editor' | 'owner';
+    e2e?: boolean;
+    e2e_root?: string;
     files: FileNode[];
 }
 
@@ -830,6 +1063,20 @@ export declare function matchedInContent(matched: unknown): boolean;
 
 export declare const messages: Record<LocaleCode, Record<string, string>>;
 
+/** Mirrors backend `model.NodeComment` (GET /api/files/comments?node_id=…). */
+declare interface NodeComment {
+    id: number;
+    node_id: number;
+    user_id: number;
+    body: string;
+    created_at: string;
+    updated_at?: string;
+    /** Joined author display name (email fallback), filled by the backend. */
+    author_name?: string;
+    /** Whether the CURRENT caller may delete this row (author or admin). */
+    can_delete?: boolean;
+}
+
 /** Mirrors backend `model.NodeVersion` (GET /api/files/versions?node_id=…). */
 declare interface NodeVersion {
     id: number;
@@ -841,6 +1088,8 @@ declare interface NodeVersion {
     created_at: string;
 }
 
+declare function openSelected(): void;
+
 export declare interface Operation {
     /** `${group}:${id}` — unique across publishers. */
     key: string;
@@ -924,6 +1173,9 @@ export declare type OperationsStore = ReturnType<typeof useOperations>;
 
 export declare type OperationStatus = 'running' | 'done' | 'error' | 'aborted';
 
+/** Parse marker JSON text; returns null when the shape is not a v1 marker. */
+export declare function parseMarker(text: string): E2eMarker | null;
+
 export declare interface PendingOp {
     id: number;
     op_type: 'copy' | 'move' | 'delete';
@@ -1030,6 +1282,8 @@ declare interface RecentNode {
     last_opened?: string;
 }
 
+declare function reload(): Promise<void>;
+
 export declare function resetAllShortcuts(): void;
 
 export declare function resetShortcut(id: string): void;
@@ -1055,6 +1309,39 @@ export declare function resolveEndpoints(config: ExplorerConfig): EndpointMap;
 /** Matched-in values the search contract allows on a hit. */
 export declare type SearchMatched = 'name' | 'content' | 'both';
 
+export declare const SecondaryPane: DefineComponent<__VLS_Props_11, {
+reload: typeof reload;
+goUp: typeof goUp;
+selectAll: typeof selectAll;
+openSelected: typeof openSelected;
+selectedNodes: typeof selectedNodes;
+getPath: typeof getPath;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+close: () => any;
+navigate: (path: string) => any;
+activate: () => any;
+"open-tab": (path: string) => any;
+transfer: (p: {
+sources: string[];
+targetWire: string;
+originWire?: string;
+}) => any;
+}, string, PublicProps, Readonly<__VLS_Props_11> & Readonly<{
+onClose?: (() => any) | undefined;
+onNavigate?: ((path: string) => any) | undefined;
+onActivate?: (() => any) | undefined;
+"onOpen-tab"?: ((path: string) => any) | undefined;
+onTransfer?: ((p: {
+sources: string[];
+targetWire: string;
+originWire?: string;
+}) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;
+
+declare function selectAll(): void;
+
+declare function selectedNodes(): FileNode[];
+
 declare type SelectionMode_2 = 'none' | 'single-file' | 'single-dir' | 'multi';
 
 /** Set (or clear back to default) a user override. '' unbinds. */
@@ -1120,6 +1407,10 @@ export declare interface ShortcutHandlers {
     onShowHelp?: () => void;
     onToggleInspector?: () => void;
     onQuickLook?: () => void;
+    onTabNew?: () => void;
+    onTabClose?: () => void;
+    onTabNext?: () => void;
+    onTabPrev?: () => void;
     hasSelection?: () => boolean;
 }
 
@@ -1178,6 +1469,42 @@ onChange?: ((value: boolean) => any) | undefined;
  */
 export declare function syncThemeStyle(id: string): void;
 
+export declare const TabBar: DefineComponent<__VLS_Props_10, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+close: (id: string) => any;
+select: (id: string) => any;
+new: () => any;
+reorder: (from: number, to: number) => any;
+"toggle-split": () => any;
+}, string, PublicProps, Readonly<__VLS_Props_10> & Readonly<{
+onClose?: ((id: string) => any) | undefined;
+onSelect?: ((id: string) => any) | undefined;
+onNew?: (() => any) | undefined;
+onReorder?: ((from: number, to: number) => any) | undefined;
+"onToggle-split"?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare interface TabItem {
+    id: string;
+    label: string;
+    /** true → the tab carries a split pane (small accent dot). */
+    split: boolean;
+}
+
+export declare type TabsApi = ReturnType<typeof useTabs>;
+
+/** Per-tab split state — the secondary pane's own location. */
+export declare interface TabSplit {
+    path: string;
+}
+
+export declare interface TabState {
+    id: string;
+    /** Location snapshot in `currentPath` form (see module docs). */
+    path: string;
+    viewMode: ViewMode;
+    split: TabSplit | null;
+}
+
 export declare const TagPicker: DefineComponent<__VLS_Props_4, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
 error: (message: string) => any;
 change: (tags: string[]) => any;
@@ -1361,6 +1688,9 @@ export declare function useFileApi(config: ExplorerConfig): {
     listVersions: (nodeId: number) => Promise<NodeVersion[]>;
     restoreVersion: (nodeId: number, versionId: number, snapshotCurrent?: boolean) => Promise<void>;
     snapshotVersion: (nodeId: number) => Promise<void>;
+    listComments: (nodeId: number) => Promise<NodeComment[]>;
+    addComment: (nodeId: number, body: string) => Promise<NodeComment>;
+    deleteComment: (id: number) => Promise<void>;
     listPermissions: (path: string) => Promise<PermissionsResponse>;
     resolveEmail: (email: string) => Promise<ResolveEmailResponse>;
     searchUsers: (q: string) => Promise<UserSearchResponse>;
@@ -1580,6 +1910,32 @@ export declare function useSelection(items: () => FileNode[]): {
 /** Reactive, override-aware view of the registry (registry order). */
 export declare function useShortcutList(): ComputedRef<ShortcutView[]>;
 
+export declare function useTabs(opts: UseTabsOptions): {
+    tabs: Ref<TabState[], TabState[]>;
+    activeId: Ref<string, string>;
+    activeTab: ComputedRef<TabState | null>;
+    activeIndex: ComputedRef<number>;
+    hasMultiple: ComputedRef<boolean>;
+    restore: () => boolean;
+    seed: (path: string, viewMode: ViewMode) => void;
+    syncActive: (patch: Partial<Pick<TabState, "path" | "viewMode">>) => void;
+    openTab: (path: string, o: {
+        viewMode: ViewMode;
+        background?: boolean;
+        split?: TabSplit | null;
+    }) => TabState;
+    closeTab: (id: string) => TabState | null;
+    activate: (id: string) => TabState | null;
+    step: (delta: number) => TabState | null;
+    move: (from: number, to: number) => void;
+    setSplit: (split: TabSplit | null) => void;
+};
+
+declare interface UseTabsOptions {
+    /** localStorage key; null disables persistence entirely. */
+    storageKey: string | null;
+}
+
 /** Reactive handle for components: `{ themeId, setTheme }`. */
 export declare function useThemeState(): {
     themeId: Ref<string>;
@@ -1590,6 +1946,13 @@ export declare function useUploadChunked(config: ExplorerConfig, api: FileApi):
     uploadFile: (opts: UploadOptions) => Promise<UploadFinalizeResponse>;
 };
 
-export declare type ViewMode = 'list' | 'grid';
+/**
+ * Check `password` against a folder marker. Resolves to the derived KEK on
+ * success, or `null` on a wrong password (GCM tag mismatch on the verify
+ * blob). Never talks to any server.
+ */
+export declare function verifyPassword(marker: E2eMarker, password: string): Promise<CryptoKey | null>;
+
+export declare type ViewMode = 'list' | 'grid' | 'gallery';
 
 export { }