@pitcher/js-api 1.26.0 → 1.27.0

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

@@ -0,0 +1,34 @@
+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;
+    isInLimits: boolean;
+    uploadStatus: UploadStatus;
+    error: string | null;
+    warning: string | null;
+    cancelErrorMessage: string;
+    genericErrorMessage: string;
+    groupsAssignmentErrorMessage?: string;
+    group_ids?: string[];
+    /**
+     * Additional destination folder IDs the file should be fanned out to AFTER
+     * the initial upload succeeds. Populated by the upload modal when the user
+     * selects multiple destinations. Empty / undefined means single-destination
+     * upload (existing behaviour). Client-side only — never serialized to the
+     * API in this shape; the upload store iterates it to drive copy calls.
+     */
+    additionalFolderIds?: string[];
+    /**
+     * Message factory invoked when the fan-out finishes with some failures.
+     * Returns the warning string to display on the upload queue item.
+     * Provided by the host (UploadFilesModal) so the warning can be localized
+     * without coupling the upload store to vue-i18n.
+     */
+    fanOutWarningMessage?: (failedFolderIds: string[]) => string;
+} & (DeviceUploadContent | FileUploadContent);

package/{lib → src/lib}/apps/browser/types/actionKeys.d.ts

@@ -3,8 +3,6 @@ export declare enum ActionKeys {
     ViewFileNewTab = "viewFileNewTab",
     ViewFolder = "viewFolder",
     ViewFolderNewTab = "viewFolderNewTab",
-    AddToFavorites = "addToFavorites",
-    RemoveFromFavorites = "removeFromFavorites",
     ViewFileDetails = "viewFileDetails",
     ViewFolderDetails = "viewFolderDetails",
     OpenDetailsPanel = "openFileDetailsPanel",

package/src/lib/apps/browser/util/sortOrder.d.ts

@@ -0,0 +1,36 @@
+import { ViewCompactFileFolder } from '../../../types/files';
+export type ReorderItem = {
+    id: string;
+    type: 'file' | 'folder';
+};
+/**
+ * Resolve the sort actually applied in the browser: an explicit per-visit choice
+ * wins; otherwise a folder with a custom order defaults to it; otherwise the
+ * user's saved sort. Kept pure (string in/out) so it's unit-testable and free of
+ * a dependency on the store's SortOption type.
+ */
+export declare function resolveSortOption(manualOverride: string | null, folderHasCustomOrder: boolean, savedDefault: string): string;
+/**
+ * The manual custom-sort position of a browser item, if one has been set.
+ * Folders carry it on `order`; files under `metadata.pitcher.order`.
+ */
+export declare function getItemOrder(item: ViewCompactFileFolder): number | undefined;
+/**
+ * Order a mixed list of files and folders by their custom position, falling back
+ * to alphabetical for items without one (and to break ties).
+ */
+export declare function sortByCustomOrder<T extends ViewCompactFileFolder>(items: T[]): T[];
+/**
+ * Move every selected item to the top or bottom of the list, consolidating a
+ * non-contiguous selection into a single contiguous block while preserving the
+ * items' relative order (matches the "Send to top / Send to bottom" spec).
+ */
+export declare function moveSelectedTo<T extends ViewCompactFileFolder>(items: T[], selectedIds: ReadonlyArray<string | number>, position: 'top' | 'bottom'): T[];
+/**
+ * Move a single dragged item directly above or below a target item (single-item
+ * drag-and-drop reorder). Returns the input unchanged when the drag is a no-op
+ * or references an item that is not in the list.
+ */
+export declare function moveItemRelativeTo<T extends ViewCompactFileFolder>(items: T[], draggedId: string | number, targetId: string | number, position: 'above' | 'below'): T[];
+/** Project a displayed list into the `{ id, type }` payload the reorder API expects. */
+export declare function toReorderItems(items: ViewCompactFileFolder[]): ReorderItem[];

package/src/lib/apps/canvas-builder/components/ui/ContentList/content.store.d.ts

@@ -0,0 +1,21 @@
+import { Ref } from 'vue';
+import { FileRetrieve } from '../../../../../../types/openapi';
+import { ContentListSection } from '../../../types/canvas';
+/**
+ * PIT-6436: this file cache is module-level and keyed only by `file_id`, with no version
+ * awareness — once a file is loaded it is never re-fetched. After a deck's file was re-uploaded
+ * (new version), the navigator / ContentList kept serving the PREVIOUS version's
+ * `content_thumbnails` (the old `versions/<old>/thumbnail-N.webp`, which still exists since
+ * versions are immutable). The backend regenerates thumbnails per version correctly — this is
+ * purely a stale client cache. Drop it whenever a deck is (re)loaded so its files are re-fetched
+ * at the current version. Called from `useCanvas` right after `activeCanvas` is set.
+ */
+export declare const resetLoadedFiles: () => void;
+declare const _default: () => {
+    files: {
+        loading: Record<string, true>;
+        loaded: Record<string, FileRetrieve>;
+    };
+    watchMissingFiles: (rawItems: Ref<ContentListSection[]>) => import('vue').WatchHandle;
+};
+export default _default;

package/src/lib/apps/canvas-builder/components/ui/ContentList/contentList.helpers.d.ts

@@ -0,0 +1,28 @@
+import { FileRetrieve } from '../../../../../../types/openapi';
+/**
+ * Resolve the CURRENT 0-based slide index for a content-backed section.
+ *
+ * PIT-6436: a ContentList entry stores a denormalized `page_index` (and `component_id`
+ * `<file>_page_N`) that is baked when the slide is added. When the file is re-uploaded with
+ * reordered pages those go stale, so the navigator / ContentList thumbnail pointed at a different
+ * slide than the section actually renders. The section's `content_background.page_id` is stable,
+ * so resolve the live position through it against the file's current `pptx_data.slides` — the same
+ * basis the Scribble read-path uses (#4677).
+ *
+ * Returns null when there is no `page_id` or it can't be found in the current slides, so callers
+ * fall back to the stored `page_index`.
+ */
+export declare function resolveCurrentSlideIndex(sectionContentData: unknown, file: FileRetrieve | undefined): number | null;
+/**
+ * Resolve a content section's CURRENT slide thumbnail URL from its Scribble's `backgroundImage`,
+ * which the read-path refreshes to the live file version + page (#4673).
+ *
+ * PIT-6436: the SectionList navigator branch otherwise falls back to the section's stored
+ * `thumbnail_url` / `metadata.thumbnail` / `slide_preview`, which are baked at section creation and
+ * are NOT refreshed on read — so after a re-upload they point at the old version + old page. The
+ * Scribble background is the same source the main slide renders from, so it stays in sync.
+ *
+ * Returns null when there is no content-background node or it has no background image, so callers
+ * fall back to the stored thumbnail (byte-identical for non-slide sections).
+ */
+export declare function resolveCurrentSectionThumbnailUrl(sectionContentData: unknown): string | null;

package/{lib → src/lib}/apps/canvas-builder/components/ui/DataCharts/types.d.ts

@@ -119,19 +119,25 @@ export interface BulkDataMapping {
     source_path: string;
     label_field: string;
     value_field?: string;
+    min_field?: string;
+    max_field?: string;
     x_field?: string;
     y_field?: string;
     r_field?: string;
 }
 export type BulkDataResult = {
     labels: string[];
-    values: (number | {
+    values: (number | [number, number] | {
         x: number;
         y: number;
         r?: number;
         originalR?: number;
     })[];
 };
+export declare function isFloatingBarMapping(mapping?: BulkDataMapping | null): boolean;
+export declare function floatingBarDatasetOptions(): {
+    grouped: false;
+};
 export declare function normalizeRValues(values: Array<{
     x: number;
     y: number;

package/{lib → src/lib}/apps/canvas-builder/components/ui/DynamicContent/useDynamicContent.d.ts

@@ -1,6 +1,6 @@
 import { ComputedRef, Ref } from 'vue';
 import { DynamicContentProps } from '../../../types/canvas';
-import { CanvasRetrieve, FileRetrieve } from '../../../../../../types/openapi';
+import { FileStatusEnum, CanvasRetrieve, FileRetrieve } from '../../../../../../types/openapi';
 export interface DynamicContentSection {
     section: CanvasRetrieve;
     index: number;
@@ -40,6 +40,7 @@ export declare function useDynamicContent(hasConfig?: Ref<boolean> | ComputedRef
             readonly template: {
                 readonly id: string;
                 name: string;
+                readonly tags?: Array<string> | undefined;
             };
             readonly sections: {
                 readonly id: string;
@@ -49,6 +50,7 @@ export declare function useDynamicContent(hasConfig?: Ref<boolean> | ComputedRef
                 metadata?: Record<string, any> | undefined;
                 is_draft: boolean;
             }[];
+            readonly section_ids?: Array<string> | undefined;
             readonly shared_link: {
                 readonly url: string;
                 short_url?: string | null | undefined;
@@ -106,6 +108,7 @@ export declare function useDynamicContent(hasConfig?: Ref<boolean> | ComputedRef
             readonly template: {
                 readonly id: string;
                 name: string;
+                readonly tags?: Array<string> | undefined;
             };
             readonly sections: {
                 readonly id: string;
@@ -115,6 +118,7 @@ export declare function useDynamicContent(hasConfig?: Ref<boolean> | ComputedRef
                 metadata?: Record<string, any> | undefined;
                 is_draft: boolean;
             }[];
+            readonly section_ids?: Array<string> | undefined;
             readonly shared_link: {
                 readonly url: string;
                 short_url?: string | null | undefined;
@@ -161,7 +165,7 @@ export declare function useDynamicContent(hasConfig?: Ref<boolean> | ComputedRef
             name?: string | undefined;
             readonly type: import('../../../../../../types/openapi').FileTypeEnum;
             readonly size: number | null;
-            readonly status: import('../../../../../../types/openapi').FileStatusEnum;
+            readonly status: FileStatusEnum;
             readonly version: {
                 readonly id: string;
                 readonly comment: string;
@@ -236,7 +240,7 @@ export declare function useDynamicContent(hasConfig?: Ref<boolean> | ComputedRef
             name?: string | undefined;
             readonly type: import('../../../../../../types/openapi').FileTypeEnum;
             readonly size: number | null;
-            readonly status: import('../../../../../../types/openapi').FileStatusEnum;
+            readonly status: FileStatusEnum;
             readonly version: {
                 readonly id: string;
                 readonly comment: string;
@@ -325,6 +329,7 @@ export declare function useDynamicContent(hasConfig?: Ref<boolean> | ComputedRef
         readonly template: {
             readonly id: string;
             name: string;
+            readonly tags?: Array<string> | undefined;
         };
         readonly sections: {
             readonly id: string;
@@ -334,6 +339,7 @@ export declare function useDynamicContent(hasConfig?: Ref<boolean> | ComputedRef
             metadata?: Record<string, any> | undefined;
             is_draft: boolean;
         }[];
+        readonly section_ids?: Array<string> | undefined;
         readonly shared_link: {
             readonly url: string;
             short_url?: string | null | undefined;
@@ -388,6 +394,7 @@ export declare function useDynamicContent(hasConfig?: Ref<boolean> | ComputedRef
         readonly template: {
             readonly id: string;
             name: string;
+            readonly tags?: Array<string> | undefined;
         };
         readonly sections: {
             readonly id: string;
@@ -397,6 +404,7 @@ export declare function useDynamicContent(hasConfig?: Ref<boolean> | ComputedRef
             metadata?: Record<string, any> | undefined;
             is_draft: boolean;
         }[];
+        readonly section_ids?: Array<string> | undefined;
         readonly shared_link: {
             readonly url: string;
             short_url?: string | null | undefined;
@@ -431,6 +439,8 @@ export declare function useDynamicContent(hasConfig?: Ref<boolean> | ComputedRef
     }> & Omit<Map<string, CanvasRetrieve>, keyof Map<any, any>>)>;
     hasSectionCached: (sectionId: string) => boolean;
     getCachedSection: (sectionId: string) => CanvasRetrieve | undefined;
-    fetchDynamicContent: (config: DynamicContentProps) => Promise<void>;
+    fetchDynamicContent: (config: DynamicContentProps, options?: {
+        silent?: boolean;
+    }) => Promise<void>;
     fetchSectionContent: (sectionId: string) => Promise<CanvasRetrieve | null>;
 };

package/src/lib/apps/canvas-builder/composables/canvasUpdateStrategy.d.ts

@@ -0,0 +1,17 @@
+import { CanvasRetrieve } from '../../../../types/openapi';
+/**
+ * Decide whether an incoming `activeCanvas` prop update requires a deep state refresh
+ * (re-cloning content.data, replacing sections, resetting canvas history) versus a
+ * cheap top-level shallow merge.
+ *
+ * Returns true when the canvas identity, content (including overrides and home_page),
+ * or sections have changed — i.e. anything that feeds the rendered slide tree. Returns
+ * false when only top-level metadata/tags/flags have changed, in which case the existing
+ * shallow merge in `updateActiveCanvasProperties` is safe (and preserves canvas-history
+ * undo state).
+ *
+ * Fixes PIT-5927: stale slide content flashes before fresh fetch lands because
+ * `canvasContent.value`/`sectionComponentOverrides.value`/`canvasHomePage.value` are only
+ * re-derived by `setActiveCanvas`, not by `updateActiveCanvasProperties`.
+ */
+export declare const needsDeepRefresh: (prev: CanvasRetrieve | null, next: CanvasRetrieve) => boolean;

package/src/lib/apps/canvas-builder/composables/lazySections.d.ts

@@ -0,0 +1,53 @@
+import { CanvasSection } from '../../../../types/openapi';
+/**
+ * Opt-in lazy section loading — client-side hydration engine.
+ *
+ * When a canvas is fetched as a "shell" (`?lazy_sections=true` + the
+ * `lazy_load_sections` setting), it carries ordered `section_ids` instead of the
+ * heavy inline `sections`. This engine drains those IDs through the batch
+ * endpoint progressively (bounded batches, capped concurrency) and feeds the
+ * hydrated bodies back so the renderer fills in as they arrive.
+ *
+ * It is a PURE async queue — no Vue, no network knowledge — so it is unit
+ * testable in isolation and reused unchanged by `useCanvas`. It is completely
+ * dormant unless `start()` is called with a non-empty ID list, which only
+ * happens for a shell canvas; the legacy fully-expanded path never touches it.
+ */
+/** Server-side `MAX_BATCH` in Django `sections_by_ids` / next-core by-ids route. */
+export declare const MAX_SECTIONS_PER_BATCH = 100;
+export interface LazySectionLoaderOptions {
+    /** Fetch the bodies for a slice of section IDs (≤ MAX_SECTIONS_PER_BATCH). */
+    fetchBatch: (sectionIds: string[]) => Promise<CanvasSection[]>;
+    /** Called with each hydrated batch as it resolves (append into the canvas). */
+    onSections: (sections: CanvasSection[]) => void;
+    /** Per-batch error sink. A failed batch is isolated; the drain continues. */
+    onError?: (error: unknown, sectionIds: string[]) => void;
+    /** Sections per request. Clamped to [1, MAX_SECTIONS_PER_BATCH]. Default 50. */
+    batchSize?: number;
+    /** Max in-flight batches. Default 2. */
+    concurrency?: number;
+}
+export interface LazySectionLoader {
+    /**
+     * Begin draining `allSectionIds`, skipping any already in `loadedSectionIds`.
+     * Order is preserved (content order = reading order, top-down). Idempotent
+     * per ID — an ID already queued/in-flight/done is never enqueued twice.
+     */
+    start(allSectionIds: string[], loadedSectionIds?: Iterable<string>): void;
+    /**
+     * Move the given IDs to the front of the remaining queue (e.g. the section a
+     * deep-link / the rep's current page points at), so they hydrate first.
+     * Unknown or already-loaded IDs are ignored. A section whose background batch
+     * previously FAILED is revived here for an on-demand retry (bounded), so
+     * navigating onto a transiently-failed section fetches it instead of leaving
+     * it blank.
+     */
+    prioritize(sectionIds: string[]): void;
+    /** Resolves once the queue is fully drained (all batches settled). */
+    ensureAll(): Promise<void>;
+    /** Cancel everything in flight and clear the queue (new deck load). */
+    reset(): void;
+    /** Remaining queued IDs not yet hydrated. */
+    pendingCount(): number;
+}
+export declare function createLazySectionLoader(options: LazySectionLoaderOptions): LazySectionLoader;