@unofficialbox/box-open-elements 0.1.0

package/dist/patterns/share/unified-share-controller.js

@@ -0,0 +1,97 @@
+import { Controller } from "../../core/index.js";
+/**
+ * The orchestration behind the unified share surface. It loads the item's share
+ * state (shared link + collaborators) from a `ShareDataSource`, drives shared-
+ * link access changes back through the same source, and tracks the active tab.
+ * Purely headless — the modal element renders `getState()` and reacts to
+ * `stateChanged`.
+ */
+export class UnifiedShareController extends Controller {
+    config;
+    // Shared in-flight guard: load() and setAccess() both talk to the same data
+    // source and write the same sharedLink/collaborators state, so they must not
+    // overlap — otherwise a slower response could clobber a newer one and silently
+    // revert the user's access change. Only one runs at a time.
+    inFlight = false;
+    constructor(config) {
+        super({
+            status: "idle",
+            sharedLink: null,
+            collaborators: [],
+            activeTab: "link",
+            updatingLink: false,
+            error: null,
+        });
+        this.config = { itemType: "file", ...config };
+    }
+    update(patch) {
+        this.setState({ ...this.state, ...patch });
+        this.emit("stateChanged", { state: this.state });
+    }
+    toMessage(caught, fallback) {
+        return caught instanceof Error ? caught.message : fallback;
+    }
+    /** Load the item's shared link and collaborators. No-op while any request is in flight. */
+    async load() {
+        if (this.inFlight) {
+            return;
+        }
+        this.inFlight = true;
+        this.update({ status: "loading", error: null });
+        try {
+            const shareState = await this.config.dataSource.getShareState({
+                itemId: this.config.itemId,
+                itemType: this.config.itemType,
+            });
+            this.update({
+                status: "ready",
+                sharedLink: shareState.sharedLink,
+                collaborators: shareState.collaborators,
+            });
+            this.emit("loaded", { sharedLink: shareState.sharedLink, collaborators: shareState.collaborators });
+        }
+        catch (caught) {
+            const error = this.toMessage(caught, "Failed to load share settings");
+            this.update({ status: "error", error });
+            this.emit("error", { error });
+        }
+        finally {
+            this.inFlight = false;
+        }
+    }
+    /** Change the shared-link access level through the data source. No-op while any request is in flight. */
+    async setAccess(access) {
+        if (this.inFlight) {
+            return;
+        }
+        const nextLink = { ...(this.state.sharedLink ?? {}), access };
+        this.inFlight = true;
+        this.update({ updatingLink: true, error: null });
+        try {
+            const shareState = await this.config.dataSource.updateSharedLink({
+                itemId: this.config.itemId,
+                itemType: this.config.itemType,
+                sharedLink: nextLink,
+            });
+            this.update({
+                updatingLink: false,
+                sharedLink: shareState.sharedLink,
+                collaborators: shareState.collaborators,
+            });
+            this.emit("linkChanged", { sharedLink: shareState.sharedLink });
+        }
+        catch (caught) {
+            const error = this.toMessage(caught, "Failed to update the shared link");
+            this.update({ updatingLink: false, error });
+            this.emit("error", { error });
+        }
+        finally {
+            this.inFlight = false;
+        }
+    }
+    setActiveTab(tab) {
+        if (tab !== this.state.activeTab) {
+            this.update({ activeTab: tab });
+        }
+    }
+}

package/dist/patterns/share/unified-share-modal.d.ts

@@ -0,0 +1,50 @@
+import type { ShareDataSource } from "./contracts.js";
+import { BaseElement } from "../../core/index.js";
+/**
+ * The unified share surface: a modal that loads an item's shared link and
+ * collaborators through a `ShareDataSource` (via a `UnifiedShareController` it
+ * owns), then presents them across a "Shared link" tab (copyable URL + access
+ * level) and a "People" tab (collaborator roster + an invite affordance). Emits
+ * `invite` when the user asks to add people (host delegates to the invite modal),
+ * `linkcopied` after a successful copy, and `close` on dismissal. Structure is
+ * built once per open so the tab controls keep focus while the body re-renders.
+ */
+export declare class BoxUnifiedShareModalElement extends BaseElement {
+    static get observedAttributes(): string[];
+    private controller;
+    private controllerUnsubscribe;
+    private dataSourceValue;
+    private bodySignature;
+    get open(): boolean;
+    set open(value: boolean);
+    get itemId(): string;
+    set itemId(value: string);
+    get itemType(): "file" | "folder";
+    set itemType(value: "file" | "folder");
+    get heading(): string;
+    set heading(value: string);
+    get dataSource(): ShareDataSource | null;
+    set dataSource(value: ShareDataSource | null);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, previous: string | null, next: string | null): void;
+    private ensureController;
+    private teardownController;
+    private refresh;
+    protected renderTemplate(): void;
+    protected update(): void;
+    private buildStructure;
+    private attachListeners;
+    /** Keep Tab / Shift+Tab focus cycling inside the dialog's tabbable controls. */
+    private trapFocus;
+    private close;
+    private copyLink;
+    private updateDynamic;
+    /** In-place refresh of the link tab's dynamic values (no DOM teardown). */
+    private patchLinkTab;
+    private renderLinkTab;
+    private renderPeopleTab;
+    private renderCollaborator;
+    private attachBodyListeners;
+}
+export declare const defineBoxUnifiedShareModalElement: (tagName?: string) => typeof BoxUnifiedShareModalElement;