@elytracms/studio 0.0.71 → 0.0.73

package/dist/lib/cms-views/view-model.d.ts

@@ -186,12 +186,24 @@ export interface AppliedViewState {
  * issues for the UI to surface.
  */
 export declare function applyViewState(collection: CollectionDef, docs: readonly CmsDocument[], localeConfig: LocaleConfig, state: TableViewState, isPublished?: IsPublished): AppliedViewState;
-/** The id of the unnamed built-in "All documents" view. */
+/** The id of the synthesized built-in "All entries" baseline view (EC-444). */
 export declare const ALL_VIEW_ID = "all";
 export declare function defaultViewState(collection: CollectionDef): TableViewState;
 /**
- * A config-declared view (EC-246b) — the flat authoring shape a collection
- * declares in `cms/` config: `{ name, filters?, sort?, columns?, hidden? }`.
+ * Resolve an authored VISIBLE column list (EC-444) into the internal two-axis
+ * `{columns, hidden}` table state. The authored list is exactly the columns shown,
+ * in order; every OTHER schema field is appended (in schema order) and hidden — the
+ * same shape {@link defaultViewState} produces, so {@link resolveColumns} renders
+ * precisely the authored list, visible, in that order. An omitted (or empty) list
+ * inherits the collection's default lens (all scalars visible, composites hidden).
+ * Unknown names in the authored list (a field the schema no longer has) are dropped.
+ */
+export declare function resolveConfigColumns(collection: CollectionDef, visible: readonly string[] | undefined): Pick<TableViewState, 'columns' | 'hidden'>;
+/** The reserved `views[]` id whose entry OVERRIDES the synthesized baseline view (EC-444). */
+export declare const DEFAULT_VIEW_OVERRIDE_ID = "default";
+/**
+ * A config-declared view (EC-246b/EC-444) — the flat authoring shape a collection
+ * declares in `cms/` config: `{ name, initial?, filters?, sort?, columns? }`.
  * Filters/sort/columns sit at the top level (no nested `state` wrapper). The
  * studio validates + interprets these; `cms-core` stores them opaquely (it
  * can't reference the filter vocabulary without a layering cycle).
@@ -199,6 +211,7 @@ export declare function defaultViewState(collection: CollectionDef): TableViewSt
 export declare const configViewSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     name: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+    initial: z.ZodOptional<z.ZodBoolean>;
     default: z.ZodOptional<z.ZodBoolean>;
     filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
         field: z.ZodString;
@@ -224,19 +237,19 @@ export declare const configViewSchema: z.ZodObject<{
         }>;
     }, z.core.$strip>>>;
     columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    hidden: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type ConfigView = z.infer<typeof configViewSchema>;
 /**
  * A resolved view: identity + the table state it restores (matches `SavedView`).
  * `name` stays a {@link LocalizedString} — resolved at the render site (EC-343), like
- * `form.label`. `default` marks the initial-view seed (see {@link defaultConfigViewId}).
+ * `form.label`. `initial` marks the first-load seed (see {@link defaultConfigViewId}),
+ * resolved from the authored `initial ?? default` flag (EC-444).
  */
 export interface ResolvedView {
     id: string;
     name: LocalizedString;
     state: TableViewState;
-    default?: boolean;
+    initial?: boolean;
 }
 /**
  * Resolve a collection's config-declared `views` into full {@link ResolvedView}s
@@ -248,26 +261,49 @@ export interface ResolvedView {
  */
 export declare function configViewsFor(collection: CollectionDef): ResolvedView[];
 /**
- * The id of the config view flagged `default: true` (EC-343) — the seed for a
- * collection's INITIAL active view. When several are flagged (a misconfiguration,
- * reported by {@link configViewIssues}) the FIRST in declaration order wins
- * deterministically; when none is flagged the caller falls back to the built-in
- * "All" lens. `undefined` when the collection declares no default view.
+ * Does the collection declare a baseline-override view (a config view whose id is
+ * {@link DEFAULT_VIEW_OVERRIDE_ID})? When true the synthesized "All entries" lens is
+ * replaced by that entry verbatim (see {@link resolveCollectionViews}), EC-444.
+ */
+export declare function hasDefaultViewOverride(collection: CollectionDef): boolean;
+/**
+ * The ordered view list a collection surfaces (EC-444): the baseline first, then the
+ * config-declared views in declaration order. The baseline is either an authored
+ * OVERRIDE (the config view whose id is {@link DEFAULT_VIEW_OVERRIDE_ID}, used
+ * VERBATIM and NOT repeated among the trailing views) or, absent one, the
+ * `synthesizedBaseline` the caller passes (the studio's translated "All entries"
+ * lens). Pure — the store supplies the synthesized baseline (i18n-bound `name`).
+ */
+export declare function resolveCollectionViews(collection: CollectionDef, synthesizedBaseline: ResolvedView): ResolvedView[];
+/**
+ * The ids of config views that still use the DEPRECATED `default` flag without the
+ * new `initial` (EC-444). Drives the one-release deprecation warning (mirrors the
+ * duplicate-default channel); empty once every view has migrated to `initial`.
+ */
+export declare function deprecatedDefaultFlagViewIds(collection: CollectionDef): string[];
+/**
+ * The id of the config view flagged `initial: true` (EC-343/EC-444; `default` read
+ * as a deprecated alias) — the seed for a collection's INITIAL active view. When
+ * several are flagged (a misconfiguration, reported by {@link configViewIssues}) the
+ * FIRST in declaration order wins deterministically; when none is flagged the caller
+ * falls back to the baseline lens. `undefined` when the collection flags none.
  */
 export declare function defaultConfigViewId(collection: CollectionDef): string | undefined;
-/** A config-level problem with a collection's declared views (EC-343). */
+/** A config-level problem with a collection's declared views (EC-343/EC-444). */
 export interface ConfigViewIssue {
+    /** Stable code (kept from EC-343 to avoid catalog churn); reads "duplicate initial". */
     code: 'duplicate-default';
     message: string;
-    /** The offending view ids (all views flagged `default`, in declaration order). */
+    /** The offending view ids (all views flagged `initial`, in declaration order). */
     viewIds: string[];
 }
 /**
- * Validate a collection's config-declared views (EC-343): at most one may set
- * `default: true`. A duplicate is returned as an explicit, structured issue —
- * never silently swallowed — so the studio can surface it (the first default still
- * wins deterministically for seeding, per {@link defaultConfigViewId}). Pure and
- * schema-only; the DOM-free counterpart of the "failures are first-class" contract.
+ * Validate a collection's config-declared views (EC-343/EC-444): at most one may set
+ * `initial: true` (`default` counted as its deprecated alias). A duplicate is returned
+ * as an explicit, structured issue — never silently swallowed — so the studio can
+ * surface it (the first still wins deterministically for seeding, per
+ * {@link defaultConfigViewId}). Pure and schema-only; the DOM-free counterpart of the
+ * "failures are first-class" contract.
  */
 export declare function configViewIssues(collection: CollectionDef): ConfigViewIssue[];
 /** Deep-cloned canonical form (stable key order via the Zod shape). */

package/dist/lib/cms-views/view-model.js

@@ -314,7 +314,7 @@ export function applyViewState(collection, docs, localeConfig, state, isPublishe
     };
 }
 // --- View state construction, equality, columns ----------------------------------
-/** The id of the unnamed built-in "All documents" view. */
+/** The id of the synthesized built-in "All entries" baseline view (EC-444). */
 export const ALL_VIEW_ID = 'all';
 /** The default (unnamed) view: no filters, no sort, every field visible. */
 /**
@@ -326,37 +326,67 @@ export const ALL_VIEW_ID = 'all';
  */
 const NON_DEFAULT_COLUMN_TYPES = new Set(['blocks', 'richText', 'object']);
 /**
- * Field names OFF the built-in "All" lens by default: the composite editing surfaces
- * (blocks/richText/object) — always noise in a scalar list — PLUS any scalar the
- * schema opts out with `form.column: false` (EC-343). Both only affect the default
- * columns: the field stays in the picker one toggle away, its form and filterability
- * are untouched, and a named view's explicit `columns` list ignores this entirely.
+ * Field names OFF the built-in baseline lens by default: exactly the composite
+ * editing surfaces (blocks/richText/object) — always noise in a scalar list. The
+ * default lens is "all scalars"; there is no per-field column opt-out any more
+ * (EC-444 hard-removed `form.column`). A field stays in the picker one toggle away,
+ * and a view curates columns by declaring an explicit `columns` list (or the
+ * `id: 'default'` baseline override).
  */
 function defaultHiddenColumns(collection) {
-    return collection.fields
-        .filter((f) => NON_DEFAULT_COLUMN_TYPES.has(f.type) || f.form?.column === false)
-        .map((f) => f.name);
+    return collection.fields.filter((f) => NON_DEFAULT_COLUMN_TYPES.has(f.type)).map((f) => f.name);
 }
 export function defaultViewState(collection) {
     return {
         filters: [],
         sort: null,
-        // Every field keeps a slot (order + picker), but the composite surfaces and any
-        // `form.column: false` scalars start hidden so the default lens is the
-        // collection's chosen scalar columns (EC-246b / EC-343).
+        // Every field keeps a slot (order + picker), but the composite surfaces start
+        // hidden so the default lens is the collection's scalar columns (EC-246b/EC-444).
         columns: orderedColumnNames(collection),
         hidden: defaultHiddenColumns(collection),
     };
 }
 /**
- * A config-declared view (EC-246b) — the flat authoring shape a collection
- * declares in `cms/` config: `{ name, filters?, sort?, columns?, hidden? }`.
+ * Resolve an authored VISIBLE column list (EC-444) into the internal two-axis
+ * `{columns, hidden}` table state. The authored list is exactly the columns shown,
+ * in order; every OTHER schema field is appended (in schema order) and hidden — the
+ * same shape {@link defaultViewState} produces, so {@link resolveColumns} renders
+ * precisely the authored list, visible, in that order. An omitted (or empty) list
+ * inherits the collection's default lens (all scalars visible, composites hidden).
+ * Unknown names in the authored list (a field the schema no longer has) are dropped.
+ */
+export function resolveConfigColumns(collection, visible) {
+    if (visible === undefined || visible.length === 0) {
+        const base = defaultViewState(collection);
+        return { columns: base.columns, hidden: base.hidden };
+    }
+    const schemaNames = orderedColumnNames(collection);
+    const schema = new Set(schemaNames);
+    const seen = new Set();
+    const shown = [];
+    for (const name of visible) {
+        if (schema.has(name) && !seen.has(name)) {
+            shown.push(name);
+            seen.add(name);
+        }
+    }
+    const rest = schemaNames.filter((name) => !seen.has(name));
+    return { columns: [...shown, ...rest], hidden: rest };
+}
+/** The reserved `views[]` id whose entry OVERRIDES the synthesized baseline view (EC-444). */
+export const DEFAULT_VIEW_OVERRIDE_ID = 'default';
+/**
+ * A config-declared view (EC-246b/EC-444) — the flat authoring shape a collection
+ * declares in `cms/` config: `{ name, initial?, filters?, sort?, columns? }`.
  * Filters/sort/columns sit at the top level (no nested `state` wrapper). The
  * studio validates + interprets these; `cms-core` stores them opaquely (it
  * can't reference the filter vocabulary without a layering cycle).
  */
 export const configViewSchema = z.object({
-    /** Optional stable id; defaults to a slug of `name`. */
+    /**
+     * Optional stable id; defaults to a slug of `name`. The reserved value
+     * {@link DEFAULT_VIEW_OVERRIDE_ID} (`'default'`) marks the baseline-override entry.
+     */
     id: z.string().min(1).optional(),
     /**
      * View label; localizable (EC-343): a plain string or a `{ locale }` map, resolved
@@ -364,17 +394,26 @@ export const configViewSchema = z.object({
      */
     name: localizedStringSchema,
     /**
-     * When true this view seeds the collection's INITIAL active view (EC-343) — the
-     * curated lens an editor lands on before picking one. At most one per collection;
-     * a duplicate is a visible validation issue ({@link configViewIssues}), never
-     * silent. The built-in "All" lens stays available and stays the fallback.
+     * When true this view seeds the collection's INITIAL active view (EC-343/EC-444) —
+     * the curated lens an editor lands on before picking one. At most one per collection;
+     * a duplicate is a visible validation issue ({@link configViewIssues}), never silent.
+     * The baseline lens stays available and stays the fallback.
+     */
+    initial: z.boolean().optional(),
+    /**
+     * @deprecated EC-444 — renamed to {@link ConfigView.initial}. Still read as an alias
+     * for one release (`initial ?? default`) with a console warning; removed next release.
+     * Distinct from a field's default VALUE and from the reserved `id: 'default'` override.
      */
     default: z.boolean().optional(),
     filters: z.array(filterClauseSchema).optional(),
     sort: viewSortSchema.nullable().optional(),
-    /** Column order; when omitted, the view inherits the collection's default columns. */
+    /**
+     * The single ordered list of VISIBLE columns (EC-444): what you list is what shows,
+     * in that order. Omit to inherit the collection's default columns (all scalars). The
+     * two-axis `{columns, hidden}` internal state is derived by {@link resolveConfigColumns}.
+     */
     columns: z.array(z.string().min(1)).optional(),
-    hidden: z.array(z.string().min(1)).optional(),
 });
 /**
  * Slug used to derive a config view's stable id from its name. A localized name
@@ -401,7 +440,6 @@ export function configViewsFor(collection) {
     const declared = collection.views;
     if (!Array.isArray(declared))
         return [];
-    const base = defaultViewState(collection);
     const seen = new Set();
     const resolved = [];
     declared.forEach((raw, index) => {
@@ -413,46 +451,100 @@ export function configViewsFor(collection) {
         if (seen.has(id))
             return;
         seen.add(id);
+        // EC-444: `initial` supersedes the deprecated `default` alias (one-release window).
+        const initial = view.initial ?? view.default;
+        const { columns, hidden } = resolveConfigColumns(collection, view.columns);
         resolved.push({
             id,
             name: view.name,
-            ...(view.default ? { default: true } : {}),
+            ...(initial ? { initial: true } : {}),
             state: normalizeViewState({
                 filters: view.filters ?? [],
                 sort: view.sort ?? null,
-                columns: view.columns && view.columns.length > 0 ? view.columns : base.columns,
-                hidden: view.hidden ?? [],
+                columns,
+                hidden,
             }),
         });
     });
     return resolved;
 }
 /**
- * The id of the config view flagged `default: true` (EC-343) — the seed for a
- * collection's INITIAL active view. When several are flagged (a misconfiguration,
- * reported by {@link configViewIssues}) the FIRST in declaration order wins
- * deterministically; when none is flagged the caller falls back to the built-in
- * "All" lens. `undefined` when the collection declares no default view.
+ * Does the collection declare a baseline-override view (a config view whose id is
+ * {@link DEFAULT_VIEW_OVERRIDE_ID})? When true the synthesized "All entries" lens is
+ * replaced by that entry verbatim (see {@link resolveCollectionViews}), EC-444.
+ */
+export function hasDefaultViewOverride(collection) {
+    return configViewsFor(collection).some((view) => view.id === DEFAULT_VIEW_OVERRIDE_ID);
+}
+/**
+ * The ordered view list a collection surfaces (EC-444): the baseline first, then the
+ * config-declared views in declaration order. The baseline is either an authored
+ * OVERRIDE (the config view whose id is {@link DEFAULT_VIEW_OVERRIDE_ID}, used
+ * VERBATIM and NOT repeated among the trailing views) or, absent one, the
+ * `synthesizedBaseline` the caller passes (the studio's translated "All entries"
+ * lens). Pure — the store supplies the synthesized baseline (i18n-bound `name`).
+ */
+export function resolveCollectionViews(collection, synthesizedBaseline) {
+    const configViews = configViewsFor(collection);
+    const overrideIndex = configViews.findIndex((view) => view.id === DEFAULT_VIEW_OVERRIDE_ID);
+    if (overrideIndex < 0)
+        return [synthesizedBaseline, ...configViews];
+    const override = configViews[overrideIndex];
+    const rest = configViews.filter((_, index) => index !== overrideIndex);
+    return [override, ...rest];
+}
+/**
+ * The ids of config views that still use the DEPRECATED `default` flag without the
+ * new `initial` (EC-444). Drives the one-release deprecation warning (mirrors the
+ * duplicate-default channel); empty once every view has migrated to `initial`.
+ */
+export function deprecatedDefaultFlagViewIds(collection) {
+    const declared = collection.views;
+    if (!Array.isArray(declared))
+        return [];
+    const seen = new Set();
+    const ids = [];
+    declared.forEach((raw, index) => {
+        const parsed = configViewSchema.safeParse(raw);
+        if (!parsed.success)
+            return;
+        const view = parsed.data;
+        const id = view.id ?? configViewId(view.name, index);
+        if (seen.has(id))
+            return;
+        seen.add(id);
+        if (view.default !== undefined && view.initial === undefined)
+            ids.push(id);
+    });
+    return ids;
+}
+/**
+ * The id of the config view flagged `initial: true` (EC-343/EC-444; `default` read
+ * as a deprecated alias) — the seed for a collection's INITIAL active view. When
+ * several are flagged (a misconfiguration, reported by {@link configViewIssues}) the
+ * FIRST in declaration order wins deterministically; when none is flagged the caller
+ * falls back to the baseline lens. `undefined` when the collection flags none.
  */
 export function defaultConfigViewId(collection) {
-    return configViewsFor(collection).find((view) => view.default)?.id;
+    return configViewsFor(collection).find((view) => view.initial)?.id;
 }
 /**
- * Validate a collection's config-declared views (EC-343): at most one may set
- * `default: true`. A duplicate is returned as an explicit, structured issue —
- * never silently swallowed — so the studio can surface it (the first default still
- * wins deterministically for seeding, per {@link defaultConfigViewId}). Pure and
- * schema-only; the DOM-free counterpart of the "failures are first-class" contract.
+ * Validate a collection's config-declared views (EC-343/EC-444): at most one may set
+ * `initial: true` (`default` counted as its deprecated alias). A duplicate is returned
+ * as an explicit, structured issue — never silently swallowed — so the studio can
+ * surface it (the first still wins deterministically for seeding, per
+ * {@link defaultConfigViewId}). Pure and schema-only; the DOM-free counterpart of the
+ * "failures are first-class" contract.
  */
 export function configViewIssues(collection) {
-    const defaults = configViewsFor(collection).filter((view) => view.default);
-    if (defaults.length <= 1)
+    const initials = configViewsFor(collection).filter((view) => view.initial);
+    if (initials.length <= 1)
         return [];
-    const viewIds = defaults.map((view) => view.id);
+    const viewIds = initials.map((view) => view.id);
     return [
         {
             code: 'duplicate-default',
-            message: `Collection "${collection.id}" declares ${defaults.length} default views (${viewIds.join(', ')}); at most one view may set \`default: true\`. Seeding "${viewIds[0]}".`,
+            message: `Collection "${collection.id}" declares ${initials.length} initial views (${viewIds.join(', ')}); at most one view may set \`initial: true\`. Seeding "${viewIds[0]}".`,
             viewIds,
         },
     ];