@webx-ui/module-catalog 0.5.0 → 0.7.0

package/dist/BulkBar.d.ts

@@ -7,14 +7,20 @@ import { BulkSelection } from './types';
  * once; a large one is a run in the background, polled here with its progress, and its refusals
  * are listed by product when it ends. The list reloads either way, and `finished` carries the ids
  * that refused — what the list leaves picked, so they can be put right and tried again.
+ *
+ * «Export» heads the menu (§8.1 of the exchange spec): the same selection, written to a file. It
+ * is the exchange's run rather than a bulk one, and is followed in «Exchange».
  */
 type __VLS_Props = {
     count: number;
     selection: BulkSelection;
+    base?: string;
 };
 declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     finished: (refused: number[]) => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     onFinished?: ((refused: number[]) => any) | undefined;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+}>, {
+    base: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
 export default _default;

package/dist/ExchangeExportDialog.d.ts

@@ -0,0 +1,19 @@
+import { BulkSelection } from './types';
+/**
+ * An export (§8.1 of the exchange spec): a saved profile, or columns chosen here with the
+ * languages their translations go out in, and a format. What goes out is the list's selection —
+ * ticked rows or everything a filter finds — or, opened from «Exchange», the whole catalogue.
+ *
+ * The run is handed back as the server answered it; the opener decides where to follow it.
+ */
+type __VLS_Props = {
+    /** What the list picked; the whole catalogue outside «Deleted» when left out. */
+    selection?: BulkSelection | null;
+    /** How many products that is, said above the choice; nothing is said without it. */
+    count?: number | null;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    count: number | null;
+    selection: BulkSelection | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/ExchangeImportPage.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The import wizard (§8.1 of the exchange spec, screen `catalog.exchange-import`): a file — an
+ * upload in pieces or an address the server downloads — then its columns matched to the
+ * catalogue's with five rows of the file under each, then how the rows are written. The last
+ * step checks the whole file without writing, or runs it; either way the run is followed in
+ * «Exchange».
+ *
+ * The settings are a described screen: a project can take a setting away or fix it with a
+ * patch, the way it does any form of the panel. A profile fills all three steps at once — its
+ * columns are laid over the header of the file, and what the file has that the profile does not
+ * know keeps the server's guess.
+ */
+type __VLS_Props = {
+    base?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    base: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    picker: HTMLInputElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/ExchangeJournalDialog.d.ts

@@ -0,0 +1,11 @@
+/**
+ * What an import changed, as the journal has it (§1 п. 12 of the exchange spec): the run's rows,
+ * one per product, with the fields each got. The record's own history links back to the run;
+ * this is the other direction — from the run to the records.
+ */
+type __VLS_Props = {
+    runId: number;
+    base: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/ExchangePage.d.ts

@@ -0,0 +1,16 @@
+/**
+ * «Exchange» (§8.1 of the exchange spec): every import and export with what it did, newest first,
+ * and the two ways in — the import wizard and the export dialog. A row opens in place: its
+ * totals, its errors, its file, its run of the journal.
+ *
+ * A run that is still going is asked after every two seconds, the way the bulk actions are; the
+ * row moves on its own while the list is open. A run started elsewhere — the wizard, the export
+ * of the product list — arrives here as `?run=<id>`, opened and followed.
+ */
+type __VLS_Props = {
+    base?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    base: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/ExchangeProfilePage.d.ts

@@ -0,0 +1,16 @@
+/**
+ * One profile of the exchange (§8.1): its head (name, format, how a CSV is read) and, by
+ * direction, either how an import writes and which header goes into which column, or the
+ * columns an export writes in their order.
+ *
+ * The head and the import's settings are the two described screens the wizard uses too, so a
+ * setting a project took away is gone from both. The columns are this page's own: a mapping is
+ * a list of pairs the server checks against the columns the caller may write.
+ */
+type __VLS_Props = {
+    base?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    base: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/ExchangeProfilesPage.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The saved profiles of the exchange (§8.1): a name, a direction, a format, and what a file of
+ * that kind looks like — so the supplier's price list of every Monday is one step, not three.
+ * A row opens the form; an import profile also starts the wizard with itself filled in.
+ */
+type __VLS_Props = {
+    base?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    base: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/ExchangeRunDetail.d.ts

@@ -0,0 +1,16 @@
+import { ExchangeRun } from './exchange';
+/**
+ * A run opened in the list of «Exchange» (§8.1): what it read and who started it, its totals,
+ * the first hundred errors with all of them a click away as CSV, the finished file of an
+ * export, and the run of the journal that holds what an import changed.
+ *
+ * The errors are asked for again when the run's count of them moves, which is how a run still
+ * going fills its table while it is open.
+ */
+type __VLS_Props = {
+    run: ExchangeRun;
+    base: string;
+    profileName?: string | null;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/exchange.d.ts

@@ -0,0 +1,151 @@
+import { Ref } from 'vue';
+import { AdminContext } from '@webx-ui/module-admin';
+import { Paginated } from '@webx-ui/core';
+import { BulkSelection } from './types';
+/**
+ * The exchange of the catalogue as the panel sees it (§8 of the exchange spec): the columns a
+ * file may carry, a look at a file before it goes in, the runs with their errors and files, and
+ * the saved profiles. The server's shapes as they are — `ExchangeController`,
+ * `ExchangeProfileController`, `ExchangeRun::toResponse()`.
+ */
+/** What a chunked upload is claimed for — the exchange's own, beside `catalog.video`. */
+export declare const EXCHANGE_PURPOSE = "catalog.exchange";
+export type ExchangeDirection = 'import' | 'export';
+export type ExchangeFormat = 'csv' | 'xlsx';
+export type ExchangeStatus = 'queued' | 'running' | 'done' | 'stopped' | 'failed';
+/** A column the caller may map or export; `locales` are the other languages of a translated one. */
+export interface ExchangeColumnInfo {
+    key: string;
+    label: string;
+    field: string;
+    localized: boolean;
+    locales: string[];
+}
+/** How an import writes (§1). Encoding and separator only when somebody knows better than a guess. */
+export interface ImportOptions {
+    key: 'sku' | 'external_id' | 'barcode' | 'id';
+    mode: 'upsert' | 'update' | 'create';
+    empty_clears: boolean;
+    absent: 'keep' | 'unpublish';
+    absent_scope: 'categories' | 'all';
+    create_missing: boolean;
+    images: 'append' | 'replace';
+    encoding?: string;
+    delimiter?: string;
+    format?: ExchangeFormat;
+}
+export declare const IMPORT_DEFAULTS: ImportOptions;
+/** A file as the server read it: how, its header, five rows, and what each header seems to be. */
+export interface ExchangeInspection {
+    format: ExchangeFormat;
+    options: {
+        encoding?: string;
+        delimiter?: string;
+    };
+    header: string[];
+    sample: string[][];
+    mapping: Record<string, string | null>;
+}
+export type ExchangeSource = {
+    upload_id: string;
+} | {
+    url: string;
+};
+export interface ExchangeRun {
+    id: number;
+    profile_id: number | null;
+    direction: ExchangeDirection;
+    format: ExchangeFormat;
+    options: Partial<ImportOptions> & Record<string, unknown>;
+    /** Import: header → column code. Export: the codes in their order. */
+    mapping: Record<string, string> | string[];
+    dry_run: boolean;
+    status: ExchangeStatus;
+    source: string | null;
+    rows_total: number;
+    rows_done: number;
+    created: number;
+    updated: number;
+    skipped: number;
+    failed: number;
+    absent: number;
+    history_id: number | null;
+    admin_id: number | null;
+    admin_name: string | null;
+    /** The finished export by a signed address, while the file is kept; null otherwise. */
+    file_url: string | null;
+    started_at: string | null;
+    finished_at: string | null;
+    created_at: string | null;
+}
+export interface ExchangeRunError {
+    row: number;
+    /** Null — the row as a whole. */
+    column: string | null;
+    value: string | null;
+    message: string;
+}
+export interface ExchangeProfile {
+    id: number;
+    name: string;
+    direction: ExchangeDirection;
+    format: ExchangeFormat;
+    options: Partial<ImportOptions> & Record<string, unknown>;
+    mapping: Record<string, string> | string[];
+    last_run_id: number | null;
+    created_at: string | null;
+    updated_at: string | null;
+}
+export type ExchangeProfileInput = Partial<Pick<ExchangeProfile, 'name' | 'direction' | 'format' | 'options' | 'mapping'>>;
+export interface ExchangeApi {
+    columns(): Promise<ExchangeColumnInfo[]>;
+    inspect(source: ExchangeSource, read?: {
+        format?: string;
+        encoding?: string;
+        delimiter?: string;
+    }): Promise<ExchangeInspection>;
+    /** A small file is done inside the request; a large one comes back queued, to be polled. */
+    startImport(source: ExchangeSource, plan: {
+        profile_id?: number;
+        mapping?: Record<string, string | null>;
+        options?: object;
+    }, dryRun: boolean): Promise<ExchangeRun>;
+    startExport(selection: BulkSelection & {
+        trashed?: boolean;
+    }, plan: {
+        profile_id: number;
+    } | {
+        columns: string[];
+        format: ExchangeFormat;
+    }): Promise<ExchangeRun>;
+    runs(query?: {
+        page?: number;
+        per_page?: number;
+    }): Promise<Paginated<ExchangeRun>>;
+    run(id: number): Promise<ExchangeRun>;
+    errors(id: number, page?: number): Promise<Paginated<ExchangeRunError>>;
+    /** Where the browser downloads every error of a run as CSV, under the panel's session. */
+    errorsFile(id: number): string;
+    /** Where the browser downloads a finished export under the panel's session. */
+    file(id: number): string;
+    profiles(direction?: ExchangeDirection): Promise<ExchangeProfile[]>;
+    profile(id: number): Promise<ExchangeProfile>;
+    createProfile(values: ExchangeProfileInput): Promise<ExchangeProfile>;
+    saveProfile(id: number, values: ExchangeProfileInput): Promise<ExchangeProfile>;
+    removeProfile(id: number): Promise<void>;
+}
+export declare function createExchangeApi(admin: AdminContext): ExchangeApi;
+export declare function isRunning(run: Pick<ExchangeRun, 'status'>): boolean;
+/** As the server spells one column of an export: `name`, or `name@de` for a translation. */
+export declare function columnCode(key: string, locale?: string | null): string;
+/** As often as the bulk actions ask (§8.1): a run of eighty thousand rows is not a request storm. */
+export declare const EXCHANGE_POLL = 2000;
+/**
+ * Runs that are still going, asked after every two seconds until they end. `watch` puts a run
+ * under watch; `onUpdate` hears every fresh answer, the last one included. A missed answer is
+ * not the end of a run — it is asked again on the next turn.
+ */
+export declare function useRunPolling(api: Pick<ExchangeApi, 'run'>, onUpdate: (run: ExchangeRun) => void): {
+    watch: (id: number) => void;
+    watching: Ref<number[]>;
+};

package/dist/exchangeWords.d.ts

@@ -0,0 +1,20 @@
+import { BadgeType } from '@webx-ui/core';
+import { ExchangeRun } from './exchange';
+type Translate = (key: string, params?: Record<string, string | number>) => string;
+export interface RunTotal {
+    key: string;
+    text: string;
+    tone: 'success' | 'danger' | 'muted' | 'default';
+}
+/**
+ * What a run did, as short lines: an import by its counters — only the ones that are not zero —
+ * an export by the products it wrote. Counted at the end of each line ("Created: 12"), because
+ * the panel has no plurals (CLAUDE.md §4).
+ */
+export declare function runTotals(run: ExchangeRun, t: Translate): RunTotal[];
+/** The badge of a run's status. A finished import with errors is done, and says so in amber. */
+export declare function runStatus(run: ExchangeRun, t: Translate): {
+    label: string;
+    type: BadgeType;
+};
+export {};

package/dist/index.d.ts

@@ -7,6 +7,7 @@ export { TONES, toneBadge, type Tone } from './tones';
 export { provideProductEditor, productEditorKey, useProductEditor, provideCatalogCategoryEditor, categoryEditorKey, useCatalogCategoryEditor, type ProductEditorContext, type CategoryEditorContext, } from './editor';
 export { createGalleryVideo, VIDEO_PURPOSE, type GalleryVideo, type GalleryVideoOptions, type UnfinishedVideo, type VideoJob, type VideoJobStage, } from './galleryVideo';
 export { useCategoryTree, useFacetRegistry, type CategoryTree, type FacetRegistry } from './store';
+export { columnCode, createExchangeApi, EXCHANGE_POLL, EXCHANGE_PURPOSE, IMPORT_DEFAULTS, isRunning, useRunPolling, type ExchangeApi, type ExchangeColumnInfo, type ExchangeDirection, type ExchangeFormat, type ExchangeInspection, type ExchangeProfile, type ExchangeProfileInput, type ExchangeRun, type ExchangeRunError, type ExchangeSource, type ExchangeStatus, type ImportOptions, } from './exchange';
 export { default as WxCatalogProductsPage } from './ProductsPage';
 export { default as WxCatalogProductEditor } from './ProductEditorPage';
 export { default as WxCatalogProductCreateDialog } from './ProductCreateDialog';
@@ -14,6 +15,11 @@ export { default as WxCatalogCategoriesPage } from './CategoriesPage';
 export { default as WxCatalogCategoryEditor } from './CategoryEditorPage';
 export { default as WxCatalogCategoryCreateDialog } from './CategoryCreateDialog';
 export { default as WxCatalogDeletedPage } from './DeletedPage';
+export { default as WxCatalogExchangePage } from './ExchangePage';
+export { default as WxCatalogExchangeImport } from './ExchangeImportPage';
+export { default as WxCatalogExchangeExportDialog } from './ExchangeExportDialog';
+export { default as WxCatalogExchangeProfiles } from './ExchangeProfilesPage';
+export { default as WxCatalogExchangeProfile } from './ExchangeProfilePage';
 export { default as WxCatalogCategoryField } from './CategoryField';
 export { default as WxCatalogFacetsField } from './FacetsField';
 export { default as WxCatalogGallery } from './GalleryField';