nuxt-ui-tools 1.11.2 → 1.13.0

package/dist/runtime/spreadsheet/types/importer.d.ts

@@ -0,0 +1,308 @@
+import type { MaybeRefOrGetter } from 'vue';
+import type { QueryFnDefinition } from '#ui-tools/shared/types/query';
+import type { MaybePromise } from '#ui-tools/shared/types/utils';
+import type { SpreadsheetColumnKind } from './columns.js';
+import type { SpreadsheetFieldGroup } from './fields.js';
+import type { SpreadsheetPrimitiveOption, SpreadsheetResolvedOption } from './options.js';
+import type { SpreadsheetCellView, SpreadsheetRow, SpreadsheetRowIssue } from './rows.js';
+import type { ExtractSpreadsheetContext, ExtractSpreadsheetExisting, ExtractSpreadsheetFieldPath, ExtractSpreadsheetOutput, ExtractSpreadsheetRow, SpreadsheetRuntimeSchema } from './schema.js';
+import type { SpreadsheetHeaderCell, SpreadsheetIssueLevel } from './shared.js';
+import type { SpreadsheetFileSource, SpreadsheetHeaderRowCandidate, SpreadsheetLayoutDetection } from './source.js';
+import type { SpreadsheetRecognizedValue, SpreadsheetValueAnswer, SpreadsheetValueQuestion, SpreadsheetValueScope } from './values.js';
+/** A context entry: a value, a ref, a getter, or a TanStack query the runtime loads. */
+export type SpreadsheetContextEntry<TValue> = MaybeRefOrGetter<TValue> | QueryFnDefinition<TValue> | (() => QueryFnDefinition<TValue>);
+export type SpreadsheetContextInput<TContext> = {
+    [TKey in keyof TContext]: SpreadsheetContextEntry<TContext[TKey]>;
+};
+export interface SpreadsheetSubmitRow<TOutput, TExisting> {
+    /** Index of the data row. */
+    index: number;
+    mode: 'create' | 'update';
+    payload: TOutput;
+    existing: TExisting | undefined;
+}
+export interface SpreadsheetSubmitParams<TOutput, TExisting, TContext> {
+    /** Payloads of new records. */
+    create: readonly TOutput[];
+    /** Payloads of stored records to update. */
+    update: readonly TOutput[];
+    /** Every payload with its row, to report rejections by row index. */
+    rows: readonly SpreadsheetSubmitRow<TOutput, TExisting>[];
+    ctx: TContext;
+    /** Position of this call when rows are sent in batches. */
+    batch: {
+        index: number;
+        count: number;
+    };
+    /** Reports how many rows of this call are done. */
+    reportProgress: (done: number) => void;
+    signal: AbortSignal;
+}
+export interface SpreadsheetSubmitRejection {
+    /** Index of the data row, from `rows[i].index`. */
+    index: number;
+    message: string;
+    field?: string;
+}
+export interface SpreadsheetSubmitResult {
+    /** Rows the server refused: they go back to review with the message. */
+    rejected?: readonly SpreadsheetSubmitRejection[];
+}
+type SpreadsheetContextOption<TContext> = [keyof TContext] extends [never] ? {
+    context?: SpreadsheetContextInput<TContext>;
+} : {
+    context: SpreadsheetContextInput<TContext>;
+};
+export type SpreadsheetImportOptions<TSchema> = SpreadsheetContextOption<ExtractSpreadsheetContext<TSchema>> & {
+    /** Imports the rows. Return `{ rejected }` to send refused rows back to review. */
+    onSubmit?: (params: SpreadsheetSubmitParams<ExtractSpreadsheetOutput<TSchema>, ExtractSpreadsheetExisting<TSchema>, ExtractSpreadsheetContext<TSchema>>) => MaybePromise<void | SpreadsheetSubmitResult>;
+    submit?: {
+        /** Rows per `onSubmit` call. Defaults to every row in one call. */
+        batchSize?: number;
+    };
+};
+export interface SpreadsheetContextModel<TContext> {
+    /** The context, complete once `ready`. */
+    readonly ctx: TContext;
+    readonly loading: boolean;
+    readonly ready: boolean;
+    readonly error: unknown;
+}
+export interface SpreadsheetFileModel {
+    readonly name: string;
+    readonly loaded: boolean;
+    readonly reading: boolean;
+    /** The file could not be read. */
+    readonly error: unknown;
+    readonly sheets: readonly {
+        name: string;
+        rowCount: number;
+    }[];
+    /** Reads a file. `name` defaults to the file's name. */
+    load(source: SpreadsheetFileSource, name?: string): void;
+    /** Reads rows copied from a spreadsheet. */
+    paste(text: string, name?: string): void;
+    clear(): void;
+}
+export interface SpreadsheetPreviewRow {
+    rowNumber: number;
+    cells: readonly string[];
+    kind: 'title' | 'header' | 'data';
+}
+export interface SpreadsheetLayoutModel {
+    readonly sheet: string | null;
+    /** Index of the header row among the sheet's rows. */
+    readonly headerRow: number;
+    readonly headerRowNumber: number;
+    readonly detection: SpreadsheetLayoutDetection | null;
+    /** The selection is what detection found. */
+    readonly detected: boolean;
+    readonly ambiguous: boolean;
+    /** Header row candidates of the current sheet, with their scores. */
+    readonly candidates: readonly SpreadsheetHeaderRowCandidate[];
+    readonly headers: readonly SpreadsheetHeaderCell[];
+    /** Rows around the header row, for a preview. */
+    readonly preview: readonly SpreadsheetPreviewRow[];
+    setSheet(name: string): void;
+    setHeaderRow(index: number): void;
+    redetect(): void;
+}
+/** Where a field stands in the file. */
+export type SpreadsheetFieldStatus = 'matched' | 'default' | 'missing' | 'unmatched';
+export interface SpreadsheetFieldState<TPath extends string = string> {
+    path: TPath;
+    label: string;
+    /** Name of the column in files. */
+    name: string;
+    description: string;
+    example: string;
+    kind: SpreadsheetColumnKind;
+    group: SpreadsheetFieldGroup | null;
+    required: boolean;
+    /** Path of the column a select reads, or `null`. */
+    from: string | null;
+    /**
+     * `matched`: a column of the file; `default`: no column, the default fills it; `missing`: a
+     * required field without a column; `unmatched`: an optional field without a column.
+     */
+    status: SpreadsheetFieldStatus;
+    header: SpreadsheetHeaderCell | null;
+    /** `file` when a header named the field, `user` when the user chose the column. */
+    assignedBy: 'file' | 'user' | null;
+    /** First distinct values of the column. */
+    samples: readonly string[];
+    /** For a missing field: a column whose values fit it. Never applied without the user. */
+    suggestion: {
+        header: SpreadsheetHeaderCell;
+        samples: readonly string[];
+    } | null;
+}
+export interface SpreadsheetColumnsModel<TPath extends string = string> {
+    readonly fields: readonly SpreadsheetFieldState<TPath>[];
+    readonly groups: readonly SpreadsheetFieldGroup[];
+    readonly missing: readonly SpreadsheetFieldState<TPath>[];
+    readonly headers: readonly SpreadsheetHeaderCell[];
+    /** Columns of the file no field reads. */
+    readonly unusedHeaders: readonly SpreadsheetHeaderCell[];
+    /** Reads the field from a column (0-based index). */
+    assign(field: TPath, header: number): void;
+    /** Imports the field without a column. */
+    ignore(field: TPath): void;
+    /** Back to what the headers name. */
+    reset(field: TPath): void;
+}
+/** A value to answer: a question, or a field and a value (with a scope id when there is one). */
+export interface SpreadsheetValueTarget<TPath extends string = string> {
+    field: TPath;
+    value: string;
+    scope?: Pick<SpreadsheetValueScope, 'id'> | null;
+}
+export interface SpreadsheetValuesModel<TPath extends string = string> {
+    /** Distinct values matching no option, answered or not. */
+    readonly questions: readonly SpreadsheetValueQuestion<TPath>[];
+    /** Questions without an answer: they block the import. */
+    readonly open: readonly SpreadsheetValueQuestion<TPath>[];
+    /** Distinct values that matched an option. */
+    readonly recognized: readonly SpreadsheetRecognizedValue<TPath>[];
+    /** Options are still loading. */
+    readonly loading: boolean;
+    /**
+     * Options of a select field, in declared order. Options depending on the row need the row
+     * index; without it, they give no options.
+     */
+    choices(field: TPath, row?: number): readonly SpreadsheetResolvedOption[];
+    /** Searches a remote list; other fields filter their options. */
+    search(field: TPath, text: string): Promise<readonly SpreadsheetResolvedOption[]>;
+    /**
+     * Answers a question: an option value, or an action. It applies to every row with the value,
+     * in the question's scope.
+     */
+    answer(question: SpreadsheetValueTarget<TPath>, answer: SpreadsheetValueAnswer | SpreadsheetPrimitiveOption): void;
+    clear(question: SpreadsheetValueTarget<TPath>): void;
+}
+export interface SpreadsheetFieldIssue {
+    row: number;
+    issue: SpreadsheetRowIssue;
+}
+export interface SpreadsheetRowsModel<TRow, TExisting, TPath extends string = string> {
+    readonly all: readonly SpreadsheetRow<TRow, TExisting>[];
+    readonly valid: readonly SpreadsheetRow<TRow, TExisting>[];
+    readonly invalid: readonly SpreadsheetRow<TRow, TExisting>[];
+    readonly discarded: readonly SpreadsheetRow<TRow, TExisting>[];
+    readonly importable: readonly SpreadsheetRow<TRow, TExisting>[];
+    /** Importable rows by mode, and skipped stored records. */
+    readonly byMode: {
+        create: number;
+        update: number;
+        skip: number;
+    };
+    /** Fields the row key reads. */
+    readonly keyFields: readonly string[];
+    /** Stored records are being looked up. */
+    readonly loading: boolean;
+    row(index: number): SpreadsheetRow<TRow, TExisting> | undefined;
+    cell(index: number, field: TPath): SpreadsheetCellView;
+    /** Distinct displayed values of a field among rows that are not discarded. */
+    distinct(field: TPath): readonly string[];
+    /** Issues of a field, or of every field. */
+    issues(field?: TPath): readonly SpreadsheetFieldIssue[];
+    edit(index: number, field: TPath, text: string): void;
+    revert(index: number, field: TPath): void;
+    discard(indexes: readonly number[]): void;
+    restore(indexes: readonly number[]): void;
+    /** The invalid rows as an xlsx file, with an Issues column. */
+    exportInvalid(): Blob;
+}
+export type SpreadsheetReviewTab = 'all' | 'importable' | 'invalid' | 'discarded';
+export type SpreadsheetReviewLevel = 'all' | 'blocking' | 'warnings';
+export type SpreadsheetReviewMode = 'all' | 'create' | 'update';
+/** One kind of issue across rows. */
+export interface SpreadsheetIssueType {
+    /** `field|code`, a review issue filter. */
+    id: string;
+    field: string;
+    code: string;
+    level: SpreadsheetIssueLevel;
+    message: string;
+    rowCount: number;
+}
+export interface SpreadsheetReviewModel<TRow, TExisting> {
+    readonly tab: SpreadsheetReviewTab;
+    readonly level: SpreadsheetReviewLevel;
+    readonly mode: SpreadsheetReviewMode;
+    /** `field|code`, `field|*` for every issue of a field, or empty. */
+    readonly issue: string;
+    readonly search: string;
+    readonly visible: readonly SpreadsheetRow<TRow, TExisting>[];
+    readonly selection: ReadonlySet<number>;
+    readonly inspected: SpreadsheetRow<TRow, TExisting> | null;
+    readonly issueTypes: readonly SpreadsheetIssueType[];
+    /** Rows with an issue on each field, and the most severe level. */
+    readonly fieldIssues: ReadonlyMap<string, {
+        rowCount: number;
+        level: SpreadsheetIssueLevel;
+    }>;
+    /** Position of the inspected row among rows with issues. */
+    readonly position: {
+        current: number;
+        total: number;
+    };
+    setTab(tab: SpreadsheetReviewTab): void;
+    setLevel(level: SpreadsheetReviewLevel): void;
+    setMode(mode: SpreadsheetReviewMode): void;
+    setIssue(issue: string): void;
+    setSearch(search: string): void;
+    select(indexes: readonly number[], selected: boolean): void;
+    clearSelection(): void;
+    inspect(index: number | null): void;
+    /** Inspects the next row with an issue. */
+    next(): void;
+    previous(): void;
+}
+export type SpreadsheetSubmitStatus = 'idle' | 'running' | 'done' | 'error';
+export interface SpreadsheetSubmitModel {
+    readonly status: SpreadsheetSubmitStatus;
+    readonly progress: {
+        done: number;
+        total: number;
+    };
+    /** Rows the server refused in the last run. */
+    readonly rejected: readonly SpreadsheetSubmitRejection[];
+    /** Rows imported in the last run. */
+    readonly imported: number;
+    readonly error: unknown;
+    run(): Promise<void>;
+    /** Sends again the rows the server refused. */
+    retryRejected(): Promise<void>;
+    reset(): void;
+}
+export interface SpreadsheetReadiness {
+    missingColumns: number;
+    openValues: number;
+    invalidRows: number;
+    importable: number;
+    /** Context, file, options, or stored records are loading. */
+    loading: boolean;
+    /** Something can be imported and nothing blocks it. */
+    canSubmit: boolean;
+}
+/** What `useSpreadsheetImport` returns. Every member is reactive and readable in templates. */
+export interface SpreadsheetImporter<TSchema extends SpreadsheetRuntimeSchema = SpreadsheetRuntimeSchema> {
+    readonly schema: TSchema;
+    readonly context: SpreadsheetContextModel<ExtractSpreadsheetContext<TSchema>>;
+    readonly file: SpreadsheetFileModel;
+    readonly layout: SpreadsheetLayoutModel;
+    readonly columns: SpreadsheetColumnsModel<ExtractSpreadsheetFieldPath<TSchema>>;
+    readonly values: SpreadsheetValuesModel<ExtractSpreadsheetFieldPath<TSchema>>;
+    readonly rows: SpreadsheetRowsModel<ExtractSpreadsheetRow<TSchema>, ExtractSpreadsheetExisting<TSchema>, ExtractSpreadsheetFieldPath<TSchema>>;
+    readonly review: SpreadsheetReviewModel<ExtractSpreadsheetRow<TSchema>, ExtractSpreadsheetExisting<TSchema>>;
+    readonly submit: SpreadsheetSubmitModel;
+    readonly readiness: SpreadsheetReadiness;
+    /** Resolves when the file is read, the context and options are loaded, and rows are parsed. */
+    ready(): Promise<void>;
+    /** The file to fill in, from the schema and the context. */
+    template(): Blob;
+    /** Clears the file and everything decided about it. */
+    reset(): void;
+}
+export {};

package/dist/runtime/spreadsheet/types/index.d.ts

@@ -1,15 +1,11 @@
-export type * from './shared';
-export type * from './source';
-export type * from './context';
 export type * from './columns';
+export type * from './fields';
 export type * from './options';
-export type * from './resolution';
-export type * from './references';
-export type * from './reference-session';
-export type * from './import';
-export type * from './pipeline';
-export type * from './inference';
 export type * from './rows';
 export type * from './schema';
-export type * from './normalized';
+export type * from './shared';
+export type * from './source';
 export type * from './validation';
+export type * from './values';
+export type * from './importer';
+export type * from './steps';

package/dist/runtime/spreadsheet/types/options.d.ts

@@ -1,15 +1,53 @@
-import type { LazyTextValue } from '#ui-tools/shared/types/utils';
+import type { QueryFnDefinition } from '#ui-tools/shared/types/query';
+import type { RemoteOptionsLoader } from '#ui-tools/shared/types/remote-options';
+import type { LazyTextValue, MaybePromise } from '#ui-tools/shared/types/utils';
 export type SpreadsheetPrimitiveOption = string | number | boolean;
+/** An option with a label; `aliases` are the other exact names this value has in files. */
 export interface SpreadsheetOptionEntry<TValue = unknown> {
-    label: LazyTextValue;
     value: TValue;
+    label: LazyTextValue;
+    aliases?: readonly string[];
 }
-export type SpreadsheetOptionItem<TValue = unknown> = SpreadsheetPrimitiveOption | SpreadsheetOptionEntry<TValue>;
+export type SpreadsheetOptionItem = SpreadsheetPrimitiveOption | SpreadsheetOptionEntry;
 export type InferSpreadsheetOptionValue<TOption> = TOption extends SpreadsheetOptionEntry<infer TValue> ? TValue : TOption extends SpreadsheetPrimitiveOption ? TOption : never;
-type InferSpreadsheetOptionsSourceItem<TSource> = TSource extends readonly (infer TOption)[] ? TOption : TSource extends (...args: infer _Args) => readonly (infer TOption)[] ? TOption : never;
-export type InferSpreadsheetOptionsSourceValue<TSource> = InferSpreadsheetOptionValue<InferSpreadsheetOptionsSourceItem<TSource>>;
-type SpreadsheetOptionsResolverFn<TParams, TOption extends SpreadsheetOptionItem> = {
-    bivarianceHack: (params: TParams) => readonly TOption[];
+/**
+ * Where a `select` column finds its options. The same sources as a form select:
+ *
+ * - a list of values or `{ value, label, aliases }`
+ * - a TanStack query returning that list
+ * - a `defineRemoteOptions` loader, for lists too large to load at once
+ * - a function of the context returning a list or a query
+ */
+export type SpreadsheetOptionsSource<TContext, TOption, TRow = unknown> = readonly TOption[] | QueryFnDefinition<readonly TOption[]> | RemoteOptionsLoader<TOption> | SpreadsheetOptionsResolver<TContext, TOption, TRow>;
+/**
+ * Options from the context, or from the row so far: `({ row }) => scalesOf(row.productId)`. A
+ * function reading `row` runs for each distinct set of values it reads and must return a list.
+ */
+export type SpreadsheetOptionsResolver<TContext, TOption, TRow = unknown> = {
+    bivarianceHack(params: {
+        ctx: TContext;
+        row: TRow;
+    }): readonly TOption[] | QueryFnDefinition<readonly TOption[]>;
 }['bivarianceHack'];
-export type SpreadsheetOptionsSource<TParams, TOption extends SpreadsheetOptionItem = SpreadsheetOptionItem> = readonly TOption[] | SpreadsheetOptionsResolverFn<TParams, TOption>;
-export {};
+/** Creates an option for a value that isn't in the list. Runs when the user imports. */
+export interface SpreadsheetOptionsCreate<TContext, TOption> {
+    handler: {
+        bivarianceHack(params: {
+            label: string;
+            ctx: TContext;
+        }): MaybePromise<TOption>;
+    }['bivarianceHack'];
+}
+/** Options with a creation handler, as in form option configs. */
+export interface SpreadsheetOptionsConfig<TContext, TOption, TRow = unknown> {
+    source: SpreadsheetOptionsSource<TContext, TOption, TRow>;
+    /** Enables `unknown: 'create'`: each new value is created once, before the rows are sent. */
+    create?: SpreadsheetOptionsCreate<TContext, TOption>;
+}
+export type SpreadsheetOptionsInput<TContext, TOption, TRow = unknown> = SpreadsheetOptionsSource<TContext, TOption, TRow> | SpreadsheetOptionsConfig<TContext, TOption, TRow>;
+/** An option as the runtime uses it: resolved label and the keys it matches exactly. */
+export interface SpreadsheetResolvedOption {
+    value: unknown;
+    label: string;
+    aliases: readonly string[];
+}

package/dist/runtime/spreadsheet/types/rows.d.ts

@@ -1,58 +1,67 @@
-import type { SpreadsheetColumnDefinition, SpreadsheetColumnGroupDefinition, SpreadsheetDynamicCollectionDefinition, SpreadsheetDynamicCollectionItemDefinition, SpreadsheetDynamicOptionGroupsDefinition } from './columns.js';
+import type { SpreadsheetResolvedOption } from './options.js';
+import type { SpreadsheetRowMode } from './schema.js';
 import type { SpreadsheetIssueLevel, SpreadsheetRecord } from './shared.js';
-export interface SpreadsheetHeaderCell {
-    index: number;
-    raw: unknown;
-    text: string;
-    normalized: string;
-}
-export interface SpreadsheetColumnAssignmentOption {
-    key: string;
-    label: string;
-    assigned: boolean;
-}
-export interface SpreadsheetColumnMatch<TColumn = SpreadsheetColumnDefinition<string, unknown, boolean, unknown>> {
-    key: string;
-    columnIndex: number;
-    header: SpreadsheetHeaderCell;
-    column: TColumn;
-}
-export interface SpreadsheetUnmatchedColumn<TColumn = SpreadsheetColumnDefinition<string, unknown, boolean, unknown>> {
-    key: string;
-    column: TColumn;
-}
-export interface SpreadsheetDynamicColumnMatch<TColumn = SpreadsheetDynamicOptionGroupsDefinition<string, string, unknown> | SpreadsheetDynamicCollectionDefinition<string, 'array' | 'record'>, TItem = SpreadsheetDynamicCollectionItemDefinition> {
-    key: string;
-    targetKey: string;
-    columnIndex: number;
-    header: SpreadsheetHeaderCell;
-    column: TColumn;
-    source: unknown;
-    item?: TItem;
-}
+/**
+ * An issue on a row. `field` is the path of the cell it is about, or `null` for the row.
+ *
+ * Codes raised by the engine: `required`, `number`, `date`, `boolean`, `parse`, `value.unknown`
+ * (a question to answer), `value.not-found`, `value.skipped`, `row.duplicate`, `row.exists`, and
+ * `server` (refused on submit). Rules use their name; `validate` issues use their `code`.
+ */
 export interface SpreadsheetRowIssue {
-    level: SpreadsheetIssueLevel;
+    field: string | null;
     code: string;
+    level: SpreadsheetIssueLevel;
     message: string;
-    rowIndex: number;
-    ruleKey?: string;
-    columnKey?: string;
-    columnIndex?: number;
-    header?: string;
 }
-export interface SpreadsheetParsedRow<TRow = SpreadsheetRecord> {
+/**
+ * Why a row is left out: discarded by the user (`manual`), by a value answered “skip these rows”
+ * (`value`), past `file.maxRows` (`limit`), a duplicate kept elsewhere (`duplicate`), or a stored
+ * record left as it is (`existing`).
+ */
+export type SpreadsheetDiscardReason = 'manual' | 'value' | 'limit' | 'duplicate' | 'existing';
+/** State of a row from its most severe issue; `discarded` rows are left out whatever their issues. */
+export type SpreadsheetRowStatus = 'valid' | 'warning' | 'blocking' | 'discarded';
+export interface SpreadsheetRow<TRow = SpreadsheetRecord, TExisting = unknown> {
+    /** 0-based index among the data rows. */
     index: number;
-    source: readonly unknown[];
+    /** Row number in the file. */
+    rowNumber: number;
     data: TRow;
     issues: readonly SpreadsheetRowIssue[];
-    isValid: boolean;
+    errors: readonly SpreadsheetRowIssue[];
+    warnings: readonly SpreadsheetRowIssue[];
+    /** Most severe issue of each field. */
+    fieldIssues: Readonly<Record<string, SpreadsheetRowIssue>>;
+    status: SpreadsheetRowStatus;
+    discardReason: SpreadsheetDiscardReason | null;
+    /** `create` for a new record, `update` or `skip` when the key matches a stored one. */
+    mode: SpreadsheetRowMode;
+    /** The stored record the row's key matches. */
+    existing: TExisting | undefined;
+    /** Fields whose value differs from the stored record. */
+    changed: readonly string[];
+    /** Fields edited in review. */
+    edited: readonly string[];
+    /** Valid and not discarded: part of the import. */
+    importable: boolean;
 }
-export interface SpreadsheetRowSummary {
-    totalRows: number;
-    validRows: number;
-    invalidRows: number;
-    issueCount: number;
+/** A cell as the table shows it. */
+export interface SpreadsheetCellView {
+    /** Current text, edits included. */
+    text: string;
+    /** Text in the file. */
+    original: string;
+    /** Text to display: the option label for a select, several items joined. */
+    display: string;
+    edited: boolean;
+    /** Filled by the column's `default`. */
+    defaulted: boolean;
+    /** Holds a value created on import. */
+    created: boolean;
+    issue: SpreadsheetRowIssue | null;
+    /** Value of the stored record, when it differs. */
+    stored: string | null;
+    /** Options of a select cell for its row. Empty for other cells. */
+    choices: readonly SpreadsheetResolvedOption[];
 }
-export type SpreadsheetStaticColumn = SpreadsheetColumnDefinition<string, unknown, boolean, unknown>;
-export type SpreadsheetStaticColumnGroup = SpreadsheetColumnGroupDefinition<string, readonly SpreadsheetRuntimeStaticColumnEntry[]>;
-export type SpreadsheetRuntimeStaticColumnEntry = SpreadsheetStaticColumn | SpreadsheetStaticColumnGroup;