@wix/patterns 1.427.0 → 1.431.0

package/dist/types/hooks/useSchemaImport.d.ts

@@ -1,20 +0,0 @@
-import type { ImportButtonConfig } from '@wix/bex-core';
-import type { TableSchemaSource } from '../components/SchemaSource/tableSchemaSource';
-import type { RenderImportFieldEditor } from '../components/ImportButton/ImportProps';
-export interface SchemaImport {
-    /** Pass to `<ImportButton config={...} />`. */
-    config: ImportButtonConfig;
-    /** Pass to `<ImportButton renderFieldEditor={...} />` — the create/edit-field modal. */
-    renderFieldEditor: RenderImportFieldEditor;
-}
-/**
- * Builds the CSV import inputs for a table's live `SchemaState` — the same one
- * `source` attaches to the table. Returns the `config` and the CMS
- * `renderFieldEditor`; pass both to `<ImportButton>`.
- *
- * Because it reads the live state, the import always matches the table's current
- * fields (including ones it just created) and needs no load of its own. `source`
- * is expected to be stable (memoized, as `CmsFieldsTable` does).
- */
-export declare function useSchemaImport<T = Record<string, unknown>>(source: TableSchemaSource<T>): SchemaImport;
-//# sourceMappingURL=useSchemaImport.d.ts.map

package/dist/types/hooks/useSchemaImport.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useSchemaImport.d.ts","sourceRoot":"","sources":["../../../src/hooks/useSchemaImport.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAe,MAAM,eAAe,CAAC;AACrE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8CAA8C,CAAC;AAEtF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,wCAAwC,CAAC;AAGtF,MAAM,WAAW,YAAY;IAC3B,+CAA+C;IAC/C,MAAM,EAAE,kBAAkB,CAAC;IAC3B,wFAAwF;IACxF,iBAAiB,EAAE,uBAAuB,CAAC;CAC5C;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACzD,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAC3B,YAAY,CASd"}

package/dist/types/schema/schemaSourceMutations.d.ts

@@ -1,9 +0,0 @@
-import type { SchemaState } from '../components/SchemaSource/SchemaState';
-import type { EditableTableMutationHandlers } from '../state/EditableTable';
-/**
- * Row write handlers read from the attached SchemaState — the schema-entry
- * default, so an editable table needs no `mutations` config. The schema loads
- * before any row can be added or edited.
- */
-export declare function schemaSourceMutations<T>(schemaState: SchemaState<T>): EditableTableMutationHandlers<T>;
-//# sourceMappingURL=schemaSourceMutations.d.ts.map

package/dist/types/schema/schemaSourceMutations.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemaSourceMutations.d.ts","sourceRoot":"","sources":["../../../src/schema/schemaSourceMutations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wCAAwC,CAAC;AAC1E,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AAK5E;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC,GAC1B,6BAA6B,CAAC,CAAC,CAAC,CAqBlC"}

package/src/components/DataExtension/platformizedImportRef.ts

@@ -1,147 +0,0 @@
-import {
-  toDataExtensionFieldType,
-  type BackupFn,
-  type Destination,
-  type FieldDraft,
-  type FieldManagement,
-  type FieldPermissions,
-  type FieldsSource,
-  type ImportButtonConfig,
-  type ImportDataSource,
-  type ImportField,
-  type JobApplicationErrorMap,
-  type NewFieldConfig,
-  type NewFieldType,
-  type PendingNewField,
-  type Schema,
-} from '@wix/bex-core';
-import type { ToolbarCollectionState } from '../../state/ToolbarCollectionState';
-
-// Resolve the four FieldDraft permission booleans from a FieldPermissions bag,
-// defaulting to read-for-apps / hidden-from-visitors when a slot is unset.
-const resolvePermissions = (permissions?: FieldPermissions) => ({
-  readApps: permissions?.installedApps?.defaultRead ?? true,
-  writeApps: permissions?.installedApps?.defaultWrite ?? true,
-  readUsers: permissions?.siteVisitors?.defaultRead ?? false,
-  writeUsers: permissions?.siteVisitors?.defaultWrite ?? false,
-});
-
-type NewFieldMapping = {
-  fieldType: NewFieldType;
-  displayName?: string;
-  config?: NewFieldConfig;
-};
-
-/**
- * Turns a column's `new` mapping into the DataExtension `FieldDraft` used to both
- * create the field and pre-fill the editor. The precise type comes from a prior
- * edit (`config.deType`) or the default for the detected type; permissions come
- * from a prior edit or the source defaults. Shared by field creation
- * (`batchAddCustomFields`, key from the resolved pending column) and the editor
- * (key derived from the name).
- */
-export const mappingToFieldDraft = (
-  mapping: NewFieldMapping,
-  key: string,
-  name: string,
-  fieldManagement: FieldManagement,
-): FieldDraft => ({
-  type: mapping.config?.deType ?? toDataExtensionFieldType(mapping.fieldType),
-  key,
-  name,
-  containsPii: mapping.config?.isPii ?? false,
-  ...resolvePermissions(
-    mapping.config?.permissions ?? fieldManagement.permissions,
-  ),
-});
-
-/**
- * Creates the pending new DataExtension fields, one `addField` per column (the
- * DataExtension service has no batch create). Each `addField` upserts the
- * source's schema in place, so the table columns refresh reactively — there's
- * no fields map to merge, hence the `void` return. Not atomic: a failure on
- * column N leaves 1..N-1 created; `startImport` surfaces it as the error state,
- * and a retry de-dupes via the editor's `existingFieldKeys`.
- */
-export const batchAddCustomFields = async (
-  fieldManagement: FieldManagement,
-  pending: PendingNewField[],
-): Promise<void> => {
-  for (const { key, displayName, mapping } of pending) {
-    await fieldManagement.addField(
-      mappingToFieldDraft(mapping, key, displayName, fieldManagement),
-    );
-  }
-};
-
-/**
- * An `ImportButtonConfig` for a platformized (non–Wix-Data) destination. Cairo
- * builds it from the consumer's inputs (via `usePlatformizedImport`) plus the
- * table's toolbar — the toolbar is needed because a DataExtension source is
- * created inside `setDataExtensionOnTable` and never handed back to the consumer.
- * Holds the stable `ToolbarCollectionState` and reads the attached fields source
- * through getters, so an import built before the source attaches (or before its
- * schema loads) still reads the right values when it runs — mirroring
- * `SchemaImportRef` reading `source.schemaState`.
- *
- * `fields` are the consumer-provided fields plus the DataExtension fields
- * currently on the table (deduped by id, consumer first).
- */
-export class PlatformizedImportRef implements ImportButtonConfig {
-  private readonly toolbar: ToolbarCollectionState<any, any>;
-  private readonly _fields: ImportField[];
-  private readonly _destination: Destination;
-  readonly backup?: BackupFn;
-  readonly jobApplicationErrorMap?: JobApplicationErrorMap;
-
-  constructor(params: {
-    toolbar: ToolbarCollectionState<any, any>;
-    fields: ImportField[];
-    destination: Destination;
-    backup?: BackupFn;
-    jobApplicationErrorMap?: JobApplicationErrorMap;
-  }) {
-    this.toolbar = params.toolbar;
-    this._fields = params.fields;
-    this._destination = params.destination;
-    this.backup = params.backup;
-    this.jobApplicationErrorMap = params.jobApplicationErrorMap;
-  }
-
-  private get fieldsSource(): FieldsSource | undefined {
-    return this.toolbar.collectionFieldsSource?.fieldsSource;
-  }
-
-  get fieldManagement(): FieldManagement | undefined {
-    return this.fieldsSource?.fieldManagement;
-  }
-
-  get fields(): ImportField[] {
-    const seen = new Set(this._fields.map((field) => field.id));
-    const dataExtensionFields = (this.fieldsSource?.fields ?? [])
-      .filter((field) => !seen.has(field.id))
-      .map((field) => ({ id: field.id, header: field.displayName }));
-    return [...this._fields, ...dataExtensionFields];
-  }
-
-  get dataSource(): ImportDataSource {
-    // Create-new-field is disabled for now — the import is mapping-only into the
-    // destination. Re-enable by restoring the block below (offers createFields +
-    // fieldManagement when the source permits adding fields).
-    return { destination: this._destination };
-
-    // const fieldManagement = this.fieldManagement;
-    // if (!fieldManagement?.canAddFields) {
-    //   return { destination: this._destination };
-    // }
-    // return {
-    //   destination: this._destination,
-    //   createFields: (pending) => batchAddCustomFields(fieldManagement, pending),
-    //   fieldManagement,
-    // };
-  }
-
-  // DataExtension refreshes its own schema in place on each `addField`, so there
-  // is no returned fields map to merge — `mergeFields` is deliberately omitted.
-  mergeFields?: (fields: Schema['fields']) => void;
-}

package/src/components/SchemaSource/schemaImportRef.ts

@@ -1,137 +0,0 @@
-import type {
-  BackupConfig,
-  BackupFn,
-  Field,
-  ImportButtonConfig,
-  ImportDataSource,
-  ImportField,
-  NewFieldDefinition,
-  Schema,
-} from '@wix/bex-core';
-import type { TableSchemaSource } from './tableSchemaSource';
-import { toPatternsFieldType } from '../ImportButton/newFieldTypeMapping';
-
-// Adapts a schema's BackupConfig (create / wait / restore steps) to the import's
-// BackupFn: snapshot on call, and hand back a `restore` used to undo the import
-// on cancel. A source without `restore` snapshots but offers no undo.
-const composeBackupFn =
-  (backup: BackupConfig): BackupFn =>
-  async (signal) => {
-    const { backupId } = await backup.create();
-    await backup.waitForCompletion(backupId, { signal });
-
-    const restore = backup.restore;
-    if (!restore) {
-      return;
-    }
-    return {
-      restore: async (restoreSignal) => {
-        const { restorationId } = await restore(backupId);
-        await backup.waitForRestoration?.(restorationId, {
-          signal: restoreSignal,
-        });
-      },
-    };
-  };
-
-// Builds the Field to create from a pending new column: import decides the key,
-// and the detected NewFieldType maps to the schema's PatternsFieldType. Import
-// only ever creates non-reference fields, so the cast is safe.
-const toField = (def: NewFieldDefinition): Field =>
-  ({
-    id: def.key,
-    displayName: def.displayName,
-    type: toPatternsFieldType(def.type),
-    ...(def.config?.validation && { validation: def.config.validation }),
-    ...(def.config?.isPii && { isPii: true }),
-    ...(def.config?.helpText && { helpText: def.config.helpText }),
-  } as Field);
-
-/**
- * An `ImportButtonConfig` that reads the table's live `SchemaState` — the same
- * one the table renders from. Every input is read on demand, so:
- *  - the async schema load needn't resolve before this is constructed, and
- *  - fields the import creates (merged back via `mergeFields`) and fields added
- *    through the field-management panel show up immediately, with no stale copy.
- *
- * Reads `source.schemaState`, which the source only populates when it attaches
- * to the table (`setOnTable`) — after this is built. Reading it through the
- * getter each time gives that late binding: `state` is `undefined` until then
- * (fields empty, no create).
- */
-export class SchemaImportRef implements ImportButtonConfig {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private readonly source: TableSchemaSource<any>;
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  constructor(source: TableSchemaSource<any>) {
-    this.source = source;
-  }
-
-  private get state() {
-    return this.source.schemaState;
-  }
-
-  get fields(): ImportField[] {
-    const state = this.state;
-    if (!state) {
-      return [];
-    }
-    return state.fields.map((f) => ({
-      id: f.id,
-      header: f.displayName,
-      // Carry the schema's required flag so the mapping step can block import
-      // while a required field is unmapped (CAIRO-4452).
-      required: f.validation?.required,
-    }));
-  }
-
-  get idFieldKey(): string | undefined {
-    return this.state?.schema?.idField;
-  }
-
-  // CMS data source: the collection id plus — only when the schema permits
-  // creating fields — the batch create callback. `updateSchema`'s presence is
-  // the create-new-field opt-in; omitting it (no permission) makes the import
-  // mapping-only. `collectionId` reads live off the attached schema (empty
-  // before attach, but nothing imports until then).
-  get dataSource(): ImportDataSource {
-    return {
-      collectionId: this.state?.source.collectionId ?? '',
-      ...(this._canAddFields && { updateSchema: this._updateSchema }),
-    };
-  }
-
-  private get _canAddFields(): boolean {
-    const state = this.state;
-    const schema = state?.schema;
-    // Require both the create-field permission and a batch action to create
-    // with; otherwise columns would default to "new" but nothing gets created
-    // and the upload writes values under keys with no field.
-    if (!schema || !state.fieldActions?.addFields) {
-      return false;
-    }
-    return state.source.canAddFields(schema);
-  }
-
-  private _updateSchema = async (
-    defs: NewFieldDefinition[],
-  ): Promise<Schema['fields'] | void> => {
-    const add = this.state?.fieldActions?.addFields;
-    if (!add) {
-      return;
-    }
-    return add(defs.map(toField));
-  };
-
-  // Merge the created fields into the live SchemaState so the table's columns
-  // update with no reload (CAIRO-4400). Reads the same state the table renders.
-  mergeFields = (fields: Schema['fields']): void => {
-    this.state?.mergeFields(fields);
-  };
-
-  get backup(): BackupFn | undefined {
-    const backup = this.state?.loadedSchema?.backend.backup;
-    return backup ? composeBackupFn(backup) : undefined;
-  }
-}

package/src/hooks/usePlatformizedImport.tsx

@@ -1,77 +0,0 @@
-import React, { useState } from 'react';
-import type {
-  BackupFn,
-  Destination,
-  ImportButtonConfig,
-  ImportField,
-  ImportState,
-  JobApplicationErrorMap,
-} from '@wix/bex-core';
-import { PlatformizedImportRef } from '../components/DataExtension/platformizedImportRef';
-import { DataExtensionImportFieldEditor } from '../components/DataExtension/DataExtensionImportFieldEditor';
-import type { RenderImportFieldEditor } from '../components/ImportButton/ImportProps';
-import type { ToolbarCollectionState } from '../state/ToolbarCollectionState';
-
-export interface PlatformizedImportParams {
-  /**
-   * The table state (e.g. `table` from `useTableCollection`) — the same one the
-   * `<Table>` renders. When the table has a DataExtension source, the import reads
-   * its live fields and can create new ones (create-new-field).
-   */
-  state: { toolbar: ToolbarCollectionState<any, any> };
-  /** Existing collection fields, for column auto-mapping. */
-  fields: ImportField[];
-  /**
-   * Platformized (non–Wix-Data) destination the import writes into, e.g.
-   * `{ storesCatalogProducts: {} }`.
-   */
-  destination: Destination;
-  /**
-   * Optional snapshot taken before the rows are uploaded; its `restore` undoes
-   * the import if the user cancels mid-import.
-   */
-  backup?: BackupFn;
-  /** See {@link JobApplicationErrorMap}. */
-  jobApplicationErrorMap?: JobApplicationErrorMap;
-}
-
-export interface PlatformizedImport {
-  /** Pass to `<ImportButton config={...} />`. */
-  config: ImportButtonConfig;
-  /** Pass to `<ImportButton renderFieldEditor={...} />` — the create/edit-field modal. */
-  renderFieldEditor: RenderImportFieldEditor;
-}
-
-/**
- * Builds the CSV import inputs for a platformized (non–Wix-Data) destination —
- * e.g. the stores catalog. Reads the table's toolbar so a DataExtension source's
- * live fields and create-new-field are wired in; `fields` are the consumer's plus
- * the DataExtension fields on the table. Returns the `config` and the
- * DataExtension create/edit-field modal; pass both to `<ImportButton>`. Mirrors
- * `useSchemaImport`, which does the same for the CMS (Wix Data) case.
- */
-export function usePlatformizedImport({
-  state,
-  fields,
-  destination,
-  backup,
-  jobApplicationErrorMap,
-}: PlatformizedImportParams): PlatformizedImport {
-  const [config] = useState(
-    () =>
-      new PlatformizedImportRef({
-        toolbar: state.toolbar,
-        fields,
-        destination,
-        backup,
-        jobApplicationErrorMap,
-      }),
-  );
-  const [renderFieldEditor] = useState<RenderImportFieldEditor>(
-    () =>
-      ({ state: importState }: { state: ImportState }) =>
-        <DataExtensionImportFieldEditor state={importState} />,
-  );
-
-  return { config, renderFieldEditor };
-}

package/src/hooks/useSchemaImport.tsx

@@ -1,35 +0,0 @@
-import React, { useState } from 'react';
-import type { ImportButtonConfig, ImportState } from '@wix/bex-core';
-import type { TableSchemaSource } from '../components/SchemaSource/tableSchemaSource';
-import { SchemaImportRef } from '../components/SchemaSource/schemaImportRef';
-import type { RenderImportFieldEditor } from '../components/ImportButton/ImportProps';
-import { CmsImportFieldEditor } from '../components/ImportButton/CmsImportFieldEditor';
-
-export interface SchemaImport {
-  /** Pass to `<ImportButton config={...} />`. */
-  config: ImportButtonConfig;
-  /** Pass to `<ImportButton renderFieldEditor={...} />` — the create/edit-field modal. */
-  renderFieldEditor: RenderImportFieldEditor;
-}
-
-/**
- * Builds the CSV import inputs for a table's live `SchemaState` — the same one
- * `source` attaches to the table. Returns the `config` and the CMS
- * `renderFieldEditor`; pass both to `<ImportButton>`.
- *
- * Because it reads the live state, the import always matches the table's current
- * fields (including ones it just created) and needs no load of its own. `source`
- * is expected to be stable (memoized, as `CmsFieldsTable` does).
- */
-export function useSchemaImport<T = Record<string, unknown>>(
-  source: TableSchemaSource<T>,
-): SchemaImport {
-  const [config] = useState(() => new SchemaImportRef(source));
-  const [renderFieldEditor] = useState<RenderImportFieldEditor>(
-    () =>
-      ({ state }: { state: ImportState }) =>
-        <CmsImportFieldEditor state={state} />,
-  );
-
-  return { config, renderFieldEditor };
-}

package/src/schema/schemaSourceMutations.ts

@@ -1,35 +0,0 @@
-import type { SchemaState } from '../components/SchemaSource/SchemaState';
-import type { EditableTableMutationHandlers } from '../state/EditableTable';
-
-const newLocalId = () =>
-  `new-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-
-/**
- * Row write handlers read from the attached SchemaState — the schema-entry
- * default, so an editable table needs no `mutations` config. The schema loads
- * before any row can be added or edited.
- */
-export function schemaSourceMutations<T>(
-  schemaState: SchemaState<T>,
-): EditableTableMutationHandlers<T> {
-  const backend = () => {
-    const loaded = schemaState.loadedSchema;
-    if (!loaded) {
-      throw new Error('The schema is not loaded yet');
-    }
-    return loaded.backend;
-  };
-  const { itemKey } = schemaState.source.collectionConfig;
-
-  return {
-    createItem: () =>
-      ({ [schemaState.schema?.idField ?? '_id']: newLocalId() } as T),
-    submitCreate: (items) =>
-      Promise.all(items.map((item) => backend().create(item))),
-    submitUpdate: (items) =>
-      Promise.all(items.map((item) => backend().update(item))),
-    submitDelete: async (items) => {
-      await backend().bulkDelete(items.map((item) => itemKey(item)));
-    },
-  };
-}