@xleddyl/nuxt-cms 0.2.1 → 0.2.3

package/dist/runtime/server/utils/registry.js

@@ -4,11 +4,13 @@ import cmsConfig from "#cms-config";
 import * as cmsTables from "#cms-tables";
 import { useRuntimeConfig } from "#imports";
 import {
+  CONTENT_PUBLISHED_AT_FIELD,
   decodeEntryTranslatableMedia,
   encodeEntryTranslatableMedia,
   pageFields,
   pageRouteOf
 } from "../../shared/index.js";
+import { normalizeTimestampFields, nowTimestamp } from "../../shared/timestamps.js";
 import { buildEntrySchema } from "../../shared/validation.js";
 let contentI18n;
 export function getContentI18n() {
@@ -30,9 +32,16 @@ export function idColumn(table) {
 }
 export function withUpdatedAt(table, values) {
   const set = { ...values };
-  if ("updatedAt" in table) set.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if ("updatedAt" in table) set.updatedAt = nowTimestamp();
   return set;
 }
+export function withTimestamps(table, values) {
+  const now = nowTimestamp();
+  const stamped = { ...values };
+  if ("createdAt" in table) stamped.createdAt ??= now;
+  if ("updatedAt" in table) stamped.updatedAt ??= now;
+  return stamped;
+}
 export function getRegistryEntry(event) {
   const name = getRouterParam(event, "collection");
   const config = cmsConfig;
@@ -58,8 +67,14 @@ export function encodeColumnValues(entry, values) {
   return encodeEntryTranslatableMedia(entry, values);
 }
 export function decodeRows(entry, rows) {
+  for (const row of rows) normalizeTimestampFields(row);
   return decodeEntryTranslatableMedia(entry, rows, getContentI18n().defaultLocale);
 }
+export function withContentDefaults(entry, values) {
+  if (entry.kind !== "content" || values.status !== "published") return values;
+  if (!values[CONTENT_PUBLISHED_AT_FIELD]) values[CONTENT_PUBLISHED_AT_FIELD] = nowTimestamp();
+  return values;
+}
 export function parseId(event) {
   return z.string().min(1).parse(getRouterParam(event, "id"));
 }

package/dist/runtime/server/utils/relations.d.ts

@@ -8,7 +8,7 @@ export declare function splitRelationValues(entry: CmsEntry, body: Row): {
     lists: Record<string, string[]>;
 };
 export declare function assertRelationTargets(entry: CmsEntry, lists: Record<string, string[]>): Promise<void>;
-export declare function saveManyToMany(db: CmsDb, name: string, sourceId: string, lists: Record<string, string[]>): Promise<void>;
+export declare function manyToManyStatements(db: CmsDb, name: string, sourceId: string, lists: Record<string, string[]>): PromiseLike<unknown>[];
 export declare function relationTitles(db: CmsDb, entry: CmsEntry, rows: Row[]): Promise<Record<string, Record<string, unknown>>>;
 export declare function attachManyToMany<T extends Row>(db: CmsDb, name: string, entry: CmsEntry, rows: T[]): Promise<T[]>;
 export {};

package/dist/runtime/server/utils/relations.js

@@ -1,10 +1,11 @@
-import { asc, eq, inArray } from "drizzle-orm";
+import { asc, inArray } from "drizzle-orm";
 import { createError } from "h3";
 import cmsConfig from "#cms-config";
 import { useDb } from "#cms-db";
 import * as cmsTables from "#cms-tables";
 import { entryFieldsFor } from "../../shared/index.js";
 import { resolveTable, tableColumns } from "./registry.js";
+import { joinWriteStatements } from "./write-statements.js";
 function manyToManyKeys(entry) {
   return Object.entries(entryFieldsFor(entry)).filter(([, field]) => field.type === "relation" && field.cardinality === "many-to-many").map(([key]) => key);
 }
@@ -50,14 +51,10 @@ export async function assertRelationTargets(entry, lists) {
     }
   }
 }
-export async function saveManyToMany(db, name, sourceId, lists) {
-  for (const [key, ids] of Object.entries(lists)) {
-    const join = joinTable(name, key);
-    await db.delete(join.table).where(eq(join.sourceId, sourceId));
-    if (ids.length) {
-      await db.insert(join.table).values(ids.map((targetId, position) => ({ sourceId, targetId, position })));
-    }
-  }
+export function manyToManyStatements(db, name, sourceId, lists) {
+  return Object.entries(lists).flatMap(
+    ([key, ids]) => joinWriteStatements(db, joinTable(name, key), sourceId, ids)
+  );
 }
 export async function relationTitles(db, entry, rows) {
   const config = cmsConfig;

package/dist/runtime/server/utils/timestamps.d.ts

@@ -0,0 +1,12 @@
+export interface TimestampColumn {
+    table: string;
+    column: string;
+}
+export interface TimestampBackfillDriver {
+    select: (query: string) => Promise<unknown[]>;
+    write: (statements: string[]) => Promise<unknown>;
+}
+export declare function timestampColumns(tables: Record<string, unknown>): TimestampColumn[];
+export declare function timestampProbeQuery(columns: TimestampColumn[]): string;
+export declare function timestampBackfillStatement({ table, column }: TimestampColumn): string;
+export declare function backfillTimestamps(tables: Record<string, unknown>, driver: TimestampBackfillDriver): Promise<number>;

package/dist/runtime/server/utils/timestamps.js

@@ -0,0 +1,48 @@
+import { is } from "drizzle-orm";
+import { SQLiteTable, getTableConfig } from "drizzle-orm/sqlite-core";
+import { SQLITE_ISO_FORMAT } from "../../shared/timestamps.js";
+const TIMESTAMP_COLUMNS = /* @__PURE__ */ new Set(["created_at", "updated_at"]);
+function quoteIdentifier(name) {
+  return `"${name.replaceAll('"', '""')}"`;
+}
+function legacyCondition(column) {
+  const target = quoteIdentifier(column);
+  return `${target} NOT LIKE '%T%' AND strftime('${SQLITE_ISO_FORMAT}', ${target}) IS NOT NULL`;
+}
+export function timestampColumns(tables) {
+  const found = [];
+  for (const table of Object.values(tables)) {
+    if (!is(table, SQLiteTable)) continue;
+    const { name, columns } = getTableConfig(table);
+    for (const column of columns) {
+      if (TIMESTAMP_COLUMNS.has(column.name)) found.push({ table: name, column: column.name });
+    }
+  }
+  return found;
+}
+export function timestampProbeQuery(columns) {
+  return columns.map(
+    ({ table, column }, index) => `SELECT ${index} AS target WHERE EXISTS (SELECT 1 FROM ${quoteIdentifier(
+      table
+    )} WHERE ${legacyCondition(column)})`
+  ).join(" UNION ALL ");
+}
+export function timestampBackfillStatement({ table, column }) {
+  const target = quoteIdentifier(column);
+  return `UPDATE ${quoteIdentifier(
+    table
+  )} SET ${target} = strftime('${SQLITE_ISO_FORMAT}', ${target}) WHERE ${legacyCondition(column)}`;
+}
+function targetIndex(row) {
+  if (Array.isArray(row)) return Number(row[0]);
+  return Number(row.target);
+}
+export async function backfillTimestamps(tables, driver) {
+  const columns = timestampColumns(tables);
+  if (!columns.length) return 0;
+  const rows = await driver.select(timestampProbeQuery(columns));
+  const stale = rows.map((row) => columns[targetIndex(row)]).filter((column) => !!column);
+  if (!stale.length) return 0;
+  await driver.write(stale.map(timestampBackfillStatement));
+  return stale.length;
+}

package/dist/runtime/server/utils/users.js

@@ -1,6 +1,7 @@
 import { eq } from "drizzle-orm";
 import { useDb } from "#cms-db";
 import { cms_users } from "#cms-tables";
+import { normalizeTimestamp } from "../../shared/timestamps.js";
 export async function findUserByEmail(email) {
   const [row] = await useDb().select().from(cms_users).where(eq(cms_users.email, email.toLowerCase()));
   return row;
@@ -28,7 +29,7 @@ export function toAccount(row) {
     email: row.email,
     name: row.name ?? null,
     role: row.role,
-    lastLoginAt: row.lastLoginAt ?? null,
-    createdAt: String(row.createdAt)
+    lastLoginAt: normalizeTimestamp(row.lastLoginAt ?? null),
+    createdAt: String(normalizeTimestamp(row.createdAt))
   };
 }

package/dist/runtime/server/utils/visibility.d.ts

@@ -0,0 +1,4 @@
+import type { SQL } from 'drizzle-orm';
+import type { AnySQLiteColumn } from 'drizzle-orm/sqlite-core';
+import type { CmsEntry } from '../../shared/index.js';
+export declare function visibilityConditions(entry: Pick<CmsEntry, 'kind' | 'drafts'>, columns: Record<string, AnySQLiteColumn>, now?: string): SQL[];

package/dist/runtime/server/utils/visibility.js

@@ -0,0 +1,12 @@
+import { eq, isNotNull, lte } from "drizzle-orm";
+import { CONTENT_PUBLISHED_AT_FIELD } from "../../shared/index.js";
+import { nowTimestamp } from "../../shared/timestamps.js";
+export function visibilityConditions(entry, columns, now = nowTimestamp()) {
+  if (!entry.drafts) return [];
+  const conditions = [];
+  if (columns.status) conditions.push(eq(columns.status, "published"));
+  const publishedAt = columns[CONTENT_PUBLISHED_AT_FIELD];
+  if (entry.kind === "content" && publishedAt)
+    conditions.push(isNotNull(publishedAt), lte(publishedAt, now));
+  return conditions;
+}

package/dist/runtime/server/utils/write-statements.d.ts

@@ -0,0 +1,33 @@
+import type { AnySQLiteColumn, BaseSQLiteDatabase, SQLiteTable } from 'drizzle-orm/sqlite-core';
+export type WriteDb = Pick<BaseSQLiteDatabase<'sync' | 'async', unknown>, 'insert' | 'update' | 'delete'>;
+export interface JoinTable {
+    table: SQLiteTable;
+    sourceId: AnySQLiteColumn;
+    targetId: AnySQLiteColumn;
+    position: AnySQLiteColumn;
+}
+export interface RebasedMediaRow {
+    key: string;
+    folder: string | null;
+    target: string | null;
+}
+export interface MediaFolderRename {
+    folders: [string, string | null][];
+    markers: string[];
+    staleMarkers: string[];
+}
+export declare const KEY_CHUNK = 90;
+export declare function chunks<T>(items: T[], size: number): T[][];
+export declare function joinWriteStatements(db: WriteDb, join: JoinTable, sourceId: string, ids: string[]): PromiseLike<unknown>[];
+export declare function mediaFolderMarkerValues(folder: string): {
+    key: string;
+    mime: string;
+    size: number;
+    width: null;
+    height: null;
+    alt: null;
+    folder: string;
+};
+export declare function planMediaFolderRename(rows: RebasedMediaRow[]): MediaFolderRename;
+export declare function mediaFolderRenameStatements(db: WriteDb, table: SQLiteTable, plan: MediaFolderRename): PromiseLike<unknown>[];
+export declare function mediaDeleteStatements(db: WriteDb, table: SQLiteTable, keys: string[]): PromiseLike<unknown>[];

package/dist/runtime/server/utils/write-statements.js

@@ -0,0 +1,75 @@
+import { eq, getTableColumns, inArray } from "drizzle-orm";
+import { isMediaFolderMarker, mediaFolderDepth, mediaFolderMarkerKey } from "../../shared/index.js";
+import { nowTimestamp } from "../../shared/timestamps.js";
+export const KEY_CHUNK = 90;
+const JOIN_INSERT_CHUNK = 30;
+export function chunks(items, size) {
+  const out = [];
+  for (let index = 0; index < items.length; index += size) {
+    out.push(items.slice(index, index + size));
+  }
+  return out;
+}
+export function joinWriteStatements(db, join, sourceId, ids) {
+  const statements = [
+    db.delete(join.table).where(eq(join.sourceId, sourceId))
+  ];
+  const rows = ids.map((targetId, position) => ({ sourceId, targetId, position }));
+  for (const chunk of chunks(rows, JOIN_INSERT_CHUNK)) {
+    statements.push(db.insert(join.table).values(chunk));
+  }
+  return statements;
+}
+export function mediaFolderMarkerValues(folder) {
+  return {
+    key: mediaFolderMarkerKey(folder),
+    mime: "application/x-empty",
+    size: 0,
+    width: null,
+    height: null,
+    alt: null,
+    folder
+  };
+}
+export function planMediaFolderRename(rows) {
+  const folders = /* @__PURE__ */ new Map();
+  const markers = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    if (!isMediaFolderMarker(row.key)) {
+      if (row.folder) folders.set(row.folder, row.target);
+    } else if (row.target) {
+      markers.add(row.target);
+    }
+  }
+  const markerKeys = new Set([...markers].map(mediaFolderMarkerKey));
+  return {
+    folders: [...folders].sort(([a], [b]) => mediaFolderDepth(a) - mediaFolderDepth(b)),
+    markers: [...markers],
+    staleMarkers: rows.filter((row) => isMediaFolderMarker(row.key) && !markerKeys.has(row.key)).map((row) => row.key)
+  };
+}
+function mediaColumns(table) {
+  const columns = getTableColumns(table);
+  return { key: columns.key, folder: columns.folder };
+}
+export function mediaFolderRenameStatements(db, table, plan) {
+  const columns = mediaColumns(table);
+  const statements = [];
+  for (const [folder, target] of plan.folders) {
+    statements.push(db.update(table).set({ folder: target }).where(eq(columns.folder, folder)));
+  }
+  for (const folder of plan.markers) {
+    const values = mediaFolderMarkerValues(folder);
+    statements.push(
+      db.insert(table).values({ ...values, createdAt: nowTimestamp() }).onConflictDoUpdate({ target: columns.key, set: values })
+    );
+  }
+  for (const keys of chunks(plan.staleMarkers, KEY_CHUNK)) {
+    statements.push(db.delete(table).where(inArray(columns.key, keys)));
+  }
+  return statements;
+}
+export function mediaDeleteStatements(db, table, keys) {
+  const { key } = mediaColumns(table);
+  return chunks(keys, KEY_CHUNK).map((chunk) => db.delete(table).where(inArray(key, chunk)));
+}

package/dist/runtime/shared/graphql-sdl.js

@@ -2,6 +2,7 @@ import {
   PAGE_PATH_FIELD,
   blockTypeName,
   blocksFieldTypeName,
+  isCollectionKind,
   isPrivateField,
   isRequiredField,
   isTranslatableField,
@@ -72,7 +73,7 @@ function entrySdl(config, name, entry) {
     if (isPrivateField(field)) continue;
     lines.push(fieldSdl(config, name, key, field));
   }
-  if (entry.kind === "collection") lines.push("  createdAt: String!");
+  if (isCollectionKind(entry)) lines.push("  createdAt: String!");
   lines.push("  updatedAt: String!");
   return `type ${typeName(name)} {
 ${lines.join("\n")}
@@ -171,6 +172,8 @@ export function renderGraphqlSdl(config) {
     );
     queryLines.push(`  ${name}ById(id: ID!, locale: String): ${gqlType}`);
     queryLines.push(`  ${name}Count(filters: ${gqlType}Filters): Int!`);
+    if (entry.kind === "content")
+      queryLines.push(`  ${name}BySlug(slug: String!, locale: String): ${gqlType}`);
   }
   return [
     ...COMMON_SDL,

package/dist/runtime/shared/index.d.ts

@@ -2,7 +2,7 @@ import type { PgTable } from 'drizzle-orm/pg-core';
 import type { SQLiteTable } from 'drizzle-orm/sqlite-core';
 import type { CmsLayoutBlock, CmsListInput } from './layout.js';
 export type CmsTable = SQLiteTable | PgTable;
-export type FieldType = 'text' | 'richtext' | 'number' | 'boolean' | 'date' | 'email' | 'slug' | 'select' | 'json' | 'media' | 'relation' | 'blocks';
+export type FieldType = 'text' | 'richtext' | 'number' | 'boolean' | 'date' | 'datetime' | 'email' | 'slug' | 'select' | 'json' | 'media' | 'relation' | 'blocks';
 export interface CmsI18n {
     locales: string[];
     defaultLocale: string;
@@ -60,8 +60,25 @@ export interface MediaUsage {
     title: string | null;
     field: string;
 }
+export interface MediaUsageEntry {
+    collection: string;
+    label: string;
+    kind: CmsEntryKind;
+    id: string | null;
+    title: string | null;
+    fields: string[];
+}
+export declare function groupMediaUsage(usage: MediaUsage[]): MediaUsageEntry[];
+export interface MediaUsageGroup {
+    key: string;
+    entries: MediaUsageEntry[];
+}
+export declare function mediaUsageGroups(usage: Record<string, MediaUsage[]>, keys: string[]): MediaUsageGroup[];
 export interface BlockConfig {
     label: string;
+    component?: string;
+    icon?: string;
+    description?: string;
     fields: Record<string, FieldConfig>;
 }
 export type ConditionValue = string | number | boolean;
@@ -115,10 +132,14 @@ export declare function isMultiSelect(field: FieldConfig): boolean;
 export declare function translatableFieldKeys(entry: EntryLike): string[];
 export declare function translatableBlockFieldKeys(block: BlockConfig): string[];
 export declare function hasTranslatableBlockFields(field: FieldConfig): boolean;
+export declare const BLOCK_HIDDEN_KEY = "hidden";
+export declare function declaresHiddenField(block: BlockConfig | undefined): boolean;
+export declare function isHiddenBlock(item: unknown): boolean;
+export declare function publicBlocks(field: FieldConfig, value: unknown): unknown;
 export declare function localizeBlock(field: FieldConfig, item: unknown, locale: string, defaultLocale: string): unknown;
 export declare function localizeBlocks(field: FieldConfig, value: unknown, locale: string, defaultLocale: string): unknown;
 export declare const CMS_GRAPHQL_BATCH_LIMIT = 20;
-export type CmsEntryKind = 'collection' | 'single' | 'page';
+export type CmsEntryKind = 'collection' | 'single' | 'page' | 'content';
 export interface CmsPageRoute {
     path: string;
     key: string;
@@ -144,10 +165,35 @@ export interface CmsEntry {
     icon?: string;
     layout?: CmsLayoutBlock[];
     list?: CmsListInput;
+    blocks?: Record<string, BlockConfig>;
+    preview?: CmsPreviewOptions;
+    declared?: CmsContentDeclared;
+}
+export interface CmsPreviewOptions {
+    component?: string;
+}
+export interface CmsContentDeclared {
+    fields: string[];
+    titleField?: unknown;
+    drafts?: unknown;
 }
 export declare const MOBILE_MEDIA_SUFFIX = "Mobile";
 export declare function mobileMediaKey(key: string): string;
 export declare function expandMobileMedia<T extends Record<string, unknown>>(config: T): T;
+export declare const CONTENT_TITLE_FIELD = "title";
+export declare const CONTENT_SLUG_FIELD = "slug";
+export declare const CONTENT_PUBLISHED_AT_FIELD = "publishedAt";
+export declare const CONTENT_BODY_FIELD = "body";
+export declare const CONTENT_SYSTEM_FIELDS: readonly ["title", "slug", "publishedAt", "excerpt", "cover", "body", "seoTitle", "seoDescription", "seoImage"];
+export type CmsContentSystemField = (typeof CONTENT_SYSTEM_FIELDS)[number];
+export declare const CONTENT_LIST_COLUMNS: string[];
+export declare function isContentEntry(entry: Pick<CmsEntry, 'kind'>): boolean;
+export declare function isCollectionKind(entry: Pick<CmsEntry, 'kind'>): boolean;
+export declare function normalizeContentEntries<T extends Record<string, unknown>>(config: T, i18n?: Pick<CmsI18n, 'locales'>): T;
+export declare function normalizeCmsConfig<T extends Record<string, unknown>>(config: T, i18n?: Pick<CmsI18n, 'locales'>): T;
+export declare function slugSourceValue(source: FieldConfig | undefined, value: unknown, defaultLocale: string): string | null;
+export declare function isScheduledContent(row: Record<string, unknown> | null | undefined, now?: Date): boolean;
+export declare function resolveBlocksMedia(field: FieldConfig, value: unknown, resolve: (key: string) => unknown): unknown;
 export declare function entryTabs(entry: Pick<CmsEntry, 'tabs'>): CmsTab[];
 export declare function fieldTab(field: FieldConfig, tabs: CmsTab[]): string | undefined;
 export declare function fieldsByTab(fields: Record<string, FieldConfig>, tabs: CmsTab[]): Record<string, Record<string, FieldConfig>>;
@@ -200,6 +246,9 @@ export interface BooleanFieldInput extends FieldInputBase {
 export interface DateFieldInput extends FieldInputBase {
     type: 'date';
 }
+export interface DateTimeFieldInput extends FieldInputBase {
+    type: 'datetime';
+}
 export interface EmailFieldInput extends FieldInputBase {
     type: 'email';
 }
@@ -229,16 +278,19 @@ export interface RelationFieldInput extends FieldInputBase {
     onDelete?: 'set null' | 'cascade' | 'restrict';
 }
 type BlockField<T> = Omit<T, 'private' | 'showIf' | 'tab'>;
-export type BlockFieldInput = BlockField<TextFieldInput> | BlockField<RichtextFieldInput> | BlockField<NumberFieldInput> | BlockField<BooleanFieldInput> | BlockField<DateFieldInput> | BlockField<EmailFieldInput> | BlockField<SelectFieldInput> | BlockField<JsonFieldInput> | Omit<BlockField<MediaFieldInput>, 'mobile'>;
+export type BlockFieldInput = BlockField<TextFieldInput> | BlockField<RichtextFieldInput> | BlockField<NumberFieldInput> | BlockField<BooleanFieldInput> | BlockField<DateFieldInput> | BlockField<DateTimeFieldInput> | BlockField<EmailFieldInput> | BlockField<SelectFieldInput> | BlockField<JsonFieldInput> | Omit<BlockField<MediaFieldInput>, 'mobile'>;
 export interface BlockInput {
     label: string;
+    component?: string;
+    icon?: string;
+    description?: string;
     fields: Record<string, BlockFieldInput>;
 }
 export interface BlocksFieldInput extends FieldInputBase {
     type: 'blocks';
     blocks: Record<string, BlockInput>;
 }
-export type CmsFieldInput = TextFieldInput | RichtextFieldInput | NumberFieldInput | BooleanFieldInput | DateFieldInput | EmailFieldInput | SlugFieldInput | SelectFieldInput | JsonFieldInput | MediaFieldInput | RelationFieldInput | BlocksFieldInput;
+export type CmsFieldInput = TextFieldInput | RichtextFieldInput | NumberFieldInput | BooleanFieldInput | DateFieldInput | DateTimeFieldInput | EmailFieldInput | SlugFieldInput | SelectFieldInput | JsonFieldInput | MediaFieldInput | RelationFieldInput | BlocksFieldInput;
 interface CmsEntryInputBase {
     id: string;
     label: string;
@@ -269,8 +321,24 @@ export interface CmsPageInput extends CmsEntryInputBase {
     overrides?: Record<string, Record<string, CmsFieldInput | null>>;
     columns?: string[];
 }
-export type CmsEntryInput = CmsCollectionInput | CmsSingleInput | CmsPageInput;
+export interface CmsContentInput {
+    id: string;
+    label: string;
+    kind: 'content';
+    icon?: string;
+    blocks: Record<string, BlockInput>;
+    fields?: Record<string, CmsFieldInput>;
+    labels?: Partial<Record<CmsContentSystemField, string>>;
+    tabs?: CmsTab[];
+    layout?: CmsLayoutBlock[];
+    list?: CmsListInput;
+    preview?: CmsPreviewOptions;
+    titleField?: never;
+    drafts?: never;
+}
+export type CmsEntryInput = CmsCollectionInput | CmsSingleInput | CmsPageInput | CmsContentInput;
 export type CmsConfigInput = Record<string, CmsEntryInput>;
 export declare function defineCmsConfig<T extends CmsConfigInput>(config: T): T;
+export declare function defineCmsBlocks<T extends Record<string, BlockInput>>(blocks: T): T;
 export * from './layout.js';
 export * from './users.js';

package/dist/runtime/shared/index.js

@@ -110,6 +110,19 @@ export function expandMediaFolders(folders) {
   }
   return [...expanded].sort();
 }
+export function groupMediaUsage(usage) {
+  const entries = /* @__PURE__ */ new Map();
+  for (const { field, ...rest } of usage) {
+    const id = `${rest.collection}\0${rest.id ?? ""}`;
+    const entry = entries.get(id);
+    if (!entry) entries.set(id, { ...rest, fields: [field] });
+    else if (!entry.fields.includes(field)) entry.fields.push(field);
+  }
+  return [...entries.values()];
+}
+export function mediaUsageGroups(usage, keys) {
+  return [...new Set(keys)].map((key) => ({ key, entries: groupMediaUsage(usage[key] ?? []) })).filter((group) => group.entries.length > 0);
+}
 export function isPrivateField(field) {
   return !!field.private;
 }
@@ -206,6 +219,20 @@ export function hasTranslatableBlockFields(field) {
     (block) => Object.values(block.fields).some(isTranslatableField)
   );
 }
+export const BLOCK_HIDDEN_KEY = "hidden";
+export function declaresHiddenField(block) {
+  return !!block && Object.hasOwn(block.fields, BLOCK_HIDDEN_KEY);
+}
+export function isHiddenBlock(item) {
+  return !!item && typeof item === "object" && item.hidden === true;
+}
+export function publicBlocks(field, value) {
+  if (!Array.isArray(value)) return value;
+  return value.filter((item) => {
+    if (!isHiddenBlock(item)) return true;
+    return declaresHiddenField(field.blocks?.[String(item.type)]);
+  });
+}
 export function localizeBlock(field, item, locale, defaultLocale) {
   if (!item || typeof item !== "object") return item;
   const block = field.blocks?.[String(item.type)];
@@ -276,6 +303,122 @@ export function expandMobileMedia(config) {
   }
   return config;
 }
+export const CONTENT_TITLE_FIELD = "title";
+export const CONTENT_SLUG_FIELD = "slug";
+export const CONTENT_PUBLISHED_AT_FIELD = "publishedAt";
+export const CONTENT_BODY_FIELD = "body";
+export const CONTENT_SYSTEM_FIELDS = [
+  "title",
+  "slug",
+  "publishedAt",
+  "excerpt",
+  "cover",
+  "body",
+  "seoTitle",
+  "seoDescription",
+  "seoImage"
+];
+export const CONTENT_LIST_COLUMNS = ["title", "status", "publishedAt"];
+export function isContentEntry(entry) {
+  return entry.kind === "content";
+}
+export function isCollectionKind(entry) {
+  return entry.kind === "collection" || entry.kind === "content";
+}
+function contentSystemFields(blocks, labels, translatable) {
+  const label = (key, fallback) => labels[key] || fallback;
+  const localized = translatable ? { translatable: true } : {};
+  return {
+    title: { label: label("title", "Title"), type: "text", required: true, ...localized },
+    slug: {
+      label: label("slug", "Slug"),
+      type: "slug",
+      from: CONTENT_TITLE_FIELD,
+      required: true,
+      description: "Filled from the title in the default language."
+    },
+    publishedAt: {
+      label: label("publishedAt", "Published at"),
+      type: "datetime",
+      description: "Empty means now when you publish. A future date schedules the item."
+    },
+    excerpt: {
+      label: label("excerpt", "Excerpt"),
+      type: "text",
+      textarea: true,
+      ...localized
+    },
+    cover: { label: label("cover", "Cover"), type: "media", mediaType: "image" },
+    body: { label: label("body", "Body"), type: "blocks", blocks },
+    seoTitle: { label: label("seoTitle", "SEO title"), type: "text", ...localized },
+    seoDescription: {
+      label: label("seoDescription", "SEO description"),
+      type: "text",
+      textarea: true,
+      ...localized
+    },
+    seoImage: { label: label("seoImage", "SEO image"), type: "media", mediaType: "image" }
+  };
+}
+function normalizeContentEntry(entry, translatable) {
+  if (entry.declared) return entry;
+  const declared = entry.fields ?? {};
+  const system = contentSystemFields(entry.blocks ?? {}, entry.labels ?? {}, translatable);
+  const extra = Object.fromEntries(
+    Object.entries(declared).filter(([key]) => !Object.hasOwn(system, key))
+  );
+  const { body, seoTitle, seoDescription, seoImage, ...head } = system;
+  return Object.assign(entry, {
+    declared: {
+      fields: Object.keys(declared),
+      ...entry.titleField !== void 0 ? { titleField: entry.titleField } : {},
+      ...entry.drafts !== void 0 ? { drafts: entry.drafts } : {}
+    },
+    titleField: CONTENT_TITLE_FIELD,
+    drafts: true,
+    fields: { ...head, ...extra, body, seoTitle, seoDescription, seoImage },
+    list: entry.list ?? { columns: [...CONTENT_LIST_COLUMNS] }
+  });
+}
+export function normalizeContentEntries(config, i18n) {
+  const translatable = !!i18n?.locales.length;
+  for (const entry of Object.values(config)) {
+    if (entry?.kind === "content") normalizeContentEntry(entry, translatable);
+  }
+  return config;
+}
+export function normalizeCmsConfig(config, i18n) {
+  return expandMobileMedia(normalizeContentEntries(config, i18n));
+}
+export function slugSourceValue(source, value, defaultLocale) {
+  if (value == null) return null;
+  if (source && isTranslatableField(source) && typeof value === "object") {
+    return value[defaultLocale] ?? null;
+  }
+  return typeof value === "string" ? value : null;
+}
+export function isScheduledContent(row, now = /* @__PURE__ */ new Date()) {
+  if (!row || row.status !== "published") return false;
+  const at = row[CONTENT_PUBLISHED_AT_FIELD];
+  if (typeof at !== "string" || !at) return false;
+  const time = new Date(at).getTime();
+  return !Number.isNaN(time) && time > now.getTime();
+}
+export function resolveBlocksMedia(field, value, resolve) {
+  if (!Array.isArray(value)) return value;
+  return value.map((item) => {
+    if (!item || typeof item !== "object") return item;
+    const block = field.blocks?.[String(item.type)];
+    if (!block) return item;
+    const resolved = { ...item };
+    for (const [key, blockField] of Object.entries(block.fields)) {
+      if (blockField.type !== "media") continue;
+      const media = resolved[key];
+      resolved[key] = typeof media === "string" && media ? resolve(media) ?? null : null;
+    }
+    return resolved;
+  });
+}
 export function entryTabs(entry) {
   return entry.tabs?.length ? entry.tabs : [];
 }
@@ -379,5 +522,8 @@ export function blockTypeName(entryName, fieldKey, blockName) {
 export function defineCmsConfig(config) {
   return config;
 }
+export function defineCmsBlocks(blocks) {
+  return blocks;
+}
 export * from "./layout.js";
 export * from "./users.js";