includio-cms 0.7.2 → 0.13.1

package/dist/core/server/fields/resolveRichtextLinks.js

@@ -1,22 +1,6 @@
 import { getCMS } from '../../cms.js';
-import { extractEntryIds as extractEntryIdsFromDoc, extractMediaIds as extractMediaIdsFromDoc, cloneDoc, walkLinkMarks, walkInlineBlockNodes } from '../../../admin/components/tiptap/structured-content-utils.js';
+import { extractEntryIds as extractEntryIdsFromDoc, cloneDoc, walkLinkMarks, walkInlineBlockNodes } from '../../../admin/components/tiptap/structured-content-utils.js';
 import { getEntrySlugPath, getSlugFromEntryData, getEntryPath } from './slugResolver.js';
-const ENTRY_ID_RE = /data-entry-id="([0-9a-f-]{36})"/g;
-function extractEntryIds(html) {
-    const ids = [];
-    for (const match of html.matchAll(ENTRY_ID_RE)) {
-        ids.push(match[1]);
-    }
-    return ids;
-}
-function resolveHtml(html, slugMap) {
-    return html.replace(/<a\s([^>]*data-entry-id="([0-9a-f-]{36})"[^>]*)>/g, (match, _attrs, id) => {
-        const slug = slugMap[id];
-        if (!slug)
-            return match;
-        return match.replace(/href="[^"]*"/, `href="${slug}"`);
-    });
-}
 /** Extract entry IDs from inlineBlock blockData relation fields. */
 function extractEntryIdsFromInlineBlocks(doc) {
     const ids = [];
@@ -59,41 +43,23 @@ export async function resolveRichtextLinks(data, fields, language) {
             if (val == null)
                 continue;
             switch (field.type) {
-                case 'richtext': {
-                    // Before translateObject, richtext is { lang: "html", ... }
-                    if (typeof val === 'object') {
-                        for (const html of Object.values(val)) {
-                            if (typeof html === 'string') {
-                                entriesIds.push(...extractEntryIds(html));
-                            }
-                        }
-                    }
-                    else if (typeof val === 'string') {
-                        entriesIds.push(...extractEntryIds(val));
-                    }
-                    break;
-                }
                 case 'content': {
-                    // Content field is localized: { lang: StructuredContentDoc, ... }
-                    if (typeof val === 'object' && val !== null) {
-                        for (const doc of Object.values(val)) {
-                            if (doc && typeof doc === 'object' && doc.type === 'doc') {
-                                entriesIds.push(...extractEntryIdsFromDoc(doc));
-                                entriesIds.push(...extractEntryIdsFromInlineBlocks(doc));
-                            }
-                        }
+                    // Content is now a single doc, not Record<lang, doc>
+                    if (val && typeof val === 'object' && val.type === 'doc') {
+                        entriesIds.push(...extractEntryIdsFromDoc(val));
+                        entriesIds.push(...extractEntryIdsFromInlineBlocks(val));
                     }
                     break;
                 }
                 case 'object':
-                    collectIds(val.data, field.fields);
+                    collectIds(val, field.fields);
                     break;
                 case 'blocks':
                     if (Array.isArray(val)) {
                         val.forEach((item) => {
-                            const objectDef = field.of.find((objDef) => objDef.slug === item.slug);
+                            const objectDef = field.of.find((objDef) => objDef.slug === item._slug);
                             if (objectDef) {
-                                collectIds(item.data, objectDef.fields);
+                                collectIds(item, objectDef.fields);
                             }
                         });
                     }
@@ -107,16 +73,28 @@ export async function resolveRichtextLinks(data, fields, language) {
     if (uniqueIds.length === 0)
         return data;
     const db = getCMS().databaseAdapter;
-    // Get entries to find their publishedVersionId
+    // Get entries and find their published versions for the target language
     const entries = await db.getEntries({ ids: uniqueIds });
-    const publishedVersionIds = entries
-        .filter((e) => e.publishedVersionId != null && e.publishedAt != null && e.publishedAt <= new Date())
-        .map((e) => e.publishedVersionId);
-    if (publishedVersionIds.length === 0)
+    const entryIds = entries.map((e) => e.id);
+    if (entryIds.length === 0)
         return data;
     const versions = await db.getEntryVersions({
-        ids: publishedVersionIds
+        entryIds,
+        lang: language
     });
+    const now = new Date();
+    // Pick latest published version per entry
+    const publishedByEntry = new Map();
+    for (const v of versions) {
+        if (v.publishedAt != null && v.publishedAt <= now) {
+            const existing = publishedByEntry.get(v.entryId);
+            if (!existing || v.versionNumber > existing.versionNumber) {
+                publishedByEntry.set(v.entryId, v);
+            }
+        }
+    }
+    if (publishedByEntry.size === 0)
+        return data;
     // Build map: entryId → collectionSlug for config lookup
     const entryConfigSlugMap = {};
     for (const entry of entries) {
@@ -124,14 +102,13 @@ export async function resolveRichtextLinks(data, fields, language) {
     }
     // Build map: entryId → resolved slug string
     const slugMap = {};
-    for (const version of versions) {
+    for (const [entryId, version] of publishedByEntry) {
         const rawData = version.data;
-        const configSlug = entryConfigSlugMap[version.entryId];
+        const configSlug = entryConfigSlugMap[entryId];
         const slugPath = configSlug ? getEntrySlugPath(configSlug) : 'seo.slug';
         const slug = getSlugFromEntryData(rawData, slugPath, language);
         if (slug) {
-            const configSlug = entryConfigSlugMap[version.entryId];
-            slugMap[version.entryId] = configSlug ? getEntryPath(configSlug, slug) : slug;
+            slugMap[entryId] = configSlug ? getEntryPath(configSlug, slug) : slug;
         }
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -145,66 +122,35 @@ export async function resolveRichtextLinks(data, fields, language) {
                 continue;
             }
             switch (field.type) {
-                case 'richtext': {
-                    if (typeof val === 'object') {
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        const resolved = {};
-                        for (const [lang, html] of Object.entries(val)) {
-                            resolved[lang] =
-                                typeof html === 'string' ? resolveHtml(html, slugMap) : html;
-                        }
-                        result[field.slug] = resolved;
-                    }
-                    else if (typeof val === 'string') {
-                        result[field.slug] = resolveHtml(val, slugMap);
-                    }
-                    break;
-                }
                 case 'content': {
                     const contentField = field;
-                    if (typeof val === 'object' && val !== null) {
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        const resolved = {};
-                        for (const [lang, doc] of Object.entries(val)) {
-                            if (doc && typeof doc === 'object' && doc.type === 'doc') {
-                                const cloned = resolveContentDoc(doc, slugMap);
-                                // Resolve inline block fields
-                                if (contentField.inlineBlocks?.length) {
-                                    walkInlineBlockNodes(cloned, (node) => {
-                                        const bd = node.attrs?.blockData;
-                                        if (!bd || typeof bd !== 'object')
-                                            return;
-                                        const def = contentField.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
-                                        if (!def)
-                                            return;
-                                        node.attrs.blockData = resolveValues(bd, def.fields);
-                                    });
-                                }
-                                resolved[lang] = cloned;
-                            }
-                            else {
-                                resolved[lang] = doc;
-                            }
+                    // Content is now a single doc
+                    if (val && typeof val === 'object' && val.type === 'doc') {
+                        const cloned = resolveContentDoc(val, slugMap);
+                        if (contentField.inlineBlocks?.length) {
+                            walkInlineBlockNodes(cloned, (node) => {
+                                const bd = node.attrs?.blockData;
+                                if (!bd || typeof bd !== 'object')
+                                    return;
+                                const def = contentField.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
+                                if (!def)
+                                    return;
+                                node.attrs.blockData = resolveValues(bd, def.fields);
+                            });
                         }
-                        result[field.slug] = resolved;
+                        result[field.slug] = cloned;
                     }
                     break;
                 }
                 case 'object':
-                    result[field.slug] = {
-                        ...val,
-                        data: resolveValues(val.data, field.fields)
-                    };
+                    result[field.slug] = resolveValues(val, field.fields);
                     break;
                 case 'blocks':
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     result[field.slug] = val.map((item) => {
-                        const objectDef = field.of.find((objDef) => objDef.slug === item.slug);
+                        const objectDef = field.of.find((objDef) => objDef.slug === item._slug);
                         if (objectDef) {
-                            return {
-                                ...item,
-                                data: resolveValues(item.data, objectDef.fields)
-                            };
+                            return resolveValues(item, objectDef.fields);
                         }
                         return item;
                     });

package/dist/core/server/fields/resolveTypographyOrphans.bench.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/server/fields/resolveTypographyOrphans.bench.js

@@ -0,0 +1,87 @@
+import { bench, describe } from 'vitest';
+import { resolveTypographyOrphans } from './resolveTypographyOrphans.js';
+function makeParagraph(text) {
+    return {
+        type: 'paragraph',
+        content: [{ type: 'text', text }]
+    };
+}
+function makeContentDoc(paragraphCount) {
+    const content = [];
+    for (let i = 0; i < paragraphCount; i++) {
+        content.push(makeParagraph(`To jest paragraf numer ${i} i zawiera tekst o kotach w domu u Ali`));
+    }
+    return { type: 'doc', content };
+}
+// Build a large entry: 50 text fields, 5 content fields (100 paragraphs each), seo, url, nested object/blocks
+function buildLargeEntry() {
+    const data = {};
+    const fields = [];
+    // 50 text fields
+    for (let i = 0; i < 50; i++) {
+        const slug = `text_${i}`;
+        data[slug] = `To jest pole tekstowe numer ${i} i zawiera polskie spójniki w tekście o kotach`;
+        fields.push({ type: 'text', slug });
+    }
+    // 5 content fields with 100 paragraphs each
+    for (let i = 0; i < 5; i++) {
+        const slug = `content_${i}`;
+        data[slug] = makeContentDoc(100);
+        fields.push({ type: 'content', slug });
+    }
+    // SEO field
+    data.seo = {
+        slug: 'test-page',
+        title: 'Strona o kotach i psach w domu u Ali',
+        description: 'Dowiedz się o kotach i psach w ogrodzie u naszych znajomych'
+    };
+    fields.push({ type: 'seo', slug: 'seo' });
+    // URL field
+    data.link = { url: '/test', text: 'Kliknij i zobacz' };
+    fields.push({ type: 'url', slug: 'link' });
+    // Nested object
+    data.hero = {
+        heading: 'Witaj w naszym domu i ogrodzie',
+        subheading: 'Zapraszamy do zwiedzania i odpoczynku'
+    };
+    fields.push({
+        type: 'object',
+        slug: 'hero',
+        fields: [
+            { type: 'text', slug: 'heading' },
+            { type: 'text', slug: 'subheading' }
+        ]
+    });
+    // Blocks
+    const blockItems = [];
+    for (let i = 0; i < 10; i++) {
+        blockItems.push({
+            _slug: 'text-block',
+            body: `Blok numer ${i} z tekstem o kotach i psach w domu`
+        });
+    }
+    data.sections = blockItems;
+    fields.push({
+        type: 'blocks',
+        slug: 'sections',
+        of: [
+            {
+                type: 'object',
+                slug: 'text-block',
+                fields: [{ type: 'text', slug: 'body' }]
+            }
+        ]
+    });
+    return { data, fields };
+}
+const { data, fields } = buildLargeEntry();
+describe('resolveTypographyOrphans benchmark', () => {
+    bench('with orphan fix', () => {
+        resolveTypographyOrphans(data, fields);
+    });
+    bench('baseline (no-op — skip resolver)', () => {
+        // Just spread to simulate similar allocation without regex
+        const result = { ...data };
+        void result;
+    });
+});

package/dist/core/server/fields/resolveTypographyOrphans.d.ts

@@ -0,0 +1,3 @@
+import type { PopulatedEntryData } from '../../../types/entries.js';
+import type { Field } from '../../../types/fields.js';
+export declare function resolveTypographyOrphans(data: PopulatedEntryData, fields: Field[]): PopulatedEntryData;

package/dist/core/server/fields/resolveTypographyOrphans.js

@@ -0,0 +1,128 @@
+import { walkNodes, cloneDoc } from '../../../admin/components/tiptap/structured-content-utils.js';
+import { fixOrphans } from './utils/fixOrphans.js';
+function fixContentDoc(doc) {
+    const cloned = cloneDoc(doc);
+    walkNodes(cloned.content, (node) => {
+        if (node.type === 'text' && node.text) {
+            node.text = fixOrphans(node.text);
+        }
+        if (node.type === 'figure' && node.attrs) {
+            if (typeof node.attrs.alt === 'string') {
+                node.attrs.alt = fixOrphans(node.attrs.alt);
+            }
+            if (typeof node.attrs.caption === 'string') {
+                node.attrs.caption = fixOrphans(node.attrs.caption);
+            }
+        }
+    });
+    return cloned;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function resolveValues(value, fields) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const result = { ...value };
+    for (const field of fields) {
+        const val = value?.[field.slug];
+        if (val == null)
+            continue;
+        switch (field.type) {
+            case 'text':
+                if (typeof val === 'string') {
+                    result[field.slug] = fixOrphans(val);
+                }
+                break;
+            case 'content':
+                if (val && typeof val === 'object' && val.type === 'doc') {
+                    const fixed = fixContentDoc(val);
+                    // Also fix inline block text fields
+                    const cf = field;
+                    if (cf.inlineBlocks?.length) {
+                        walkNodes(fixed.content, (node) => {
+                            if (node.type !== 'inlineBlock')
+                                return;
+                            const bd = node.attrs?.blockData;
+                            if (!bd || typeof bd !== 'object')
+                                return;
+                            const def = cf.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
+                            if (def) {
+                                node.attrs.blockData = resolveValues(bd, def.fields);
+                            }
+                        });
+                    }
+                    result[field.slug] = fixed;
+                }
+                break;
+            case 'seo':
+                if (val && typeof val === 'object') {
+                    const seo = { ...val };
+                    if (seo.title)
+                        seo.title = fixOrphans(seo.title);
+                    if (seo.description)
+                        seo.description = fixOrphans(seo.description);
+                    result[field.slug] = seo;
+                }
+                break;
+            case 'url':
+                if (val && typeof val === 'object') {
+                    // After resolveUrlFields, text may be a flat string or Record<lang, string>
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const url = { ...val };
+                    if (typeof url.text === 'string') {
+                        url.text = fixOrphans(url.text);
+                    }
+                    else if (url.text && typeof url.text === 'object') {
+                        const fixedText = {};
+                        for (const [lang, text] of Object.entries(url.text)) {
+                            fixedText[lang] = fixOrphans(text);
+                        }
+                        url.text = fixedText;
+                    }
+                    result[field.slug] = url;
+                }
+                break;
+            case 'object':
+                result[field.slug] = resolveValues(val, field.fields);
+                break;
+            case 'blocks':
+                if (Array.isArray(val)) {
+                    result[field.slug] = val.map((item) => {
+                        const blockDef = field.of.find((d) => d.slug === item._slug);
+                        if (blockDef) {
+                            return resolveValues(item, blockDef.fields);
+                        }
+                        return item;
+                    });
+                }
+                break;
+            case 'array':
+                if (field.of === 'text' && Array.isArray(val)) {
+                    result[field.slug] = val.map((item) => typeof item === 'string' ? fixOrphans(item) : item);
+                }
+                else if (field.of === 'url' && Array.isArray(val)) {
+                    result[field.slug] = val.map((item) => {
+                        if (item && typeof item === 'object') {
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            const url = { ...item };
+                            if (typeof url.text === 'string') {
+                                url.text = fixOrphans(url.text);
+                            }
+                            else if (url.text && typeof url.text === 'object') {
+                                const fixedText = {};
+                                for (const [lang, text] of Object.entries(url.text)) {
+                                    fixedText[lang] = fixOrphans(text);
+                                }
+                                url.text = fixedText;
+                            }
+                            return url;
+                        }
+                        return item;
+                    });
+                }
+                break;
+        }
+    }
+    return result;
+}
+export function resolveTypographyOrphans(data, fields) {
+    return resolveValues(data, fields);
+}

package/dist/core/server/fields/resolveUrlFields.js

@@ -59,34 +59,30 @@ export async function resolveUrlFields(data, fields, language) {
                     break;
                 }
                 case 'object':
-                    collectIds(val.data, field.fields);
+                    collectIds(val, field.fields);
                     break;
                 case 'blocks':
                     if (Array.isArray(val)) {
                         val.forEach((item) => {
-                            // Find the object definition for this item based on its slug
-                            const objectDef = field.of.find((objDef) => objDef.slug === item.slug);
+                            const objectDef = field.of.find((objDef) => objDef.slug === item._slug);
                             if (objectDef) {
-                                collectIds(item.data, objectDef.fields);
+                                collectIds(item, objectDef.fields);
                             }
                         });
                     }
                     break;
                 case 'content': {
                     const cf = field;
-                    if (typeof val === 'object' && val !== null && cf.inlineBlocks?.length) {
-                        for (const doc of Object.values(val)) {
-                            if (doc && typeof doc === 'object' && doc.type === 'doc') {
-                                walkInlineBlockNodes(doc, (node) => {
-                                    const bd = node.attrs?.blockData;
-                                    if (!bd || typeof bd !== 'object')
-                                        return;
-                                    const def = cf.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
-                                    if (def)
-                                        collectIds(bd, def.fields);
-                                });
-                            }
-                        }
+                    // Content is now a single doc, not Record<lang, doc>
+                    if (val && typeof val === 'object' && val.type === 'doc' && cf.inlineBlocks?.length) {
+                        walkInlineBlockNodes(val, (node) => {
+                            const bd = node.attrs?.blockData;
+                            if (!bd || typeof bd !== 'object')
+                                return;
+                            const def = cf.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
+                            if (def)
+                                collectIds(bd, def.fields);
+                        });
                     }
                     break;
                 }
@@ -108,12 +104,24 @@ export async function resolveUrlFields(data, fields, language) {
     if (entriesIds.length > 0) {
         // Use raw DB calls to avoid recursive populateEntryData → resolveUrlFields loop
         const dbEntries = await getDbEntries({ ids: entriesIds });
-        const publishedVersionIds = dbEntries
-            .map((e) => e.publishedVersionId)
-            .filter((id) => id != null);
-        if (publishedVersionIds.length > 0) {
-            const versions = await getDbEntryVersions({ ids: publishedVersionIds });
-            const versionByEntryId = new Map(versions.map((v) => [v.entryId, v]));
+        const entryIds = dbEntries.map((e) => e.id);
+        if (entryIds.length > 0) {
+            // Get published versions for the target language
+            const versions = await getDbEntryVersions({
+                entryIds,
+                lang: language
+            });
+            const now = new Date();
+            // Group by entry, pick latest published
+            const versionByEntryId = new Map();
+            for (const v of versions) {
+                if (v.publishedAt != null && v.publishedAt <= now) {
+                    const existing = versionByEntryId.get(v.entryId);
+                    if (!existing || v.versionNumber > existing.versionNumber) {
+                        versionByEntryId.set(v.entryId, v);
+                    }
+                }
+            }
             for (const entry of dbEntries) {
                 const version = versionByEntryId.get(entry.id);
                 if (!version)
@@ -178,50 +186,33 @@ export async function resolveUrlFields(data, fields, language) {
                     break;
                 }
                 case 'object':
-                    result[field.slug] = {
-                        ...val,
-                        data: resolveValues(val.data, field.fields)
-                    };
+                    result[field.slug] = resolveValues(val, field.fields);
                     break;
                 case 'blocks':
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     result[field.slug] = val.map((item) => {
-                        // Find the object definition for this item based on its slug
-                        const objectDef = field.of.find((objDef) => objDef.slug === item.slug);
+                        const objectDef = field.of.find((objDef) => objDef.slug === item._slug);
                         if (objectDef) {
-                            return {
-                                ...item,
-                                data: resolveValues(item.data, objectDef.fields)
-                            };
+                            return resolveValues(item, objectDef.fields);
                         }
-                        // If no matching object definition found, return item unchanged
                         return item;
                     });
                     break;
                 case 'content': {
                     const cf = field;
-                    if (typeof val === 'object' && val !== null && cf.inlineBlocks?.length) {
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        const resolved = {};
-                        for (const [lang, doc] of Object.entries(val)) {
-                            if (doc && typeof doc === 'object' && doc.type === 'doc') {
-                                const cloned = cloneDoc(doc);
-                                walkInlineBlockNodes(cloned, (node) => {
-                                    const bd = node.attrs?.blockData;
-                                    if (!bd || typeof bd !== 'object')
-                                        return;
-                                    const def = cf.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
-                                    if (!def)
-                                        return;
-                                    node.attrs.blockData = resolveValues(bd, def.fields);
-                                });
-                                resolved[lang] = cloned;
-                            }
-                            else {
-                                resolved[lang] = doc;
-                            }
-                        }
-                        result[field.slug] = resolved;
+                    // Content is now a single doc, not Record<lang, doc>
+                    if (val && typeof val === 'object' && val.type === 'doc' && cf.inlineBlocks?.length) {
+                        const cloned = cloneDoc(val);
+                        walkInlineBlockNodes(cloned, (node) => {
+                            const bd = node.attrs?.blockData;
+                            if (!bd || typeof bd !== 'object')
+                                return;
+                            const def = cf.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
+                            if (!def)
+                                return;
+                            node.attrs.blockData = resolveValues(bd, def.fields);
+                        });
+                        result[field.slug] = cloned;
                     }
                     break;
                 }

package/dist/core/server/fields/utils/fixOrphans.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Replace regular space after single-letter Polish conjunctions with non-breaking space.
+ * Idempotent — already-fixed text (with \u00A0) is not modified.
+ */
+export declare function fixOrphans(text: string): string;

package/dist/core/server/fields/utils/fixOrphans.js

@@ -0,0 +1,12 @@
+/**
+ * Polish orphan conjunctions that should not appear at line end.
+ * Lowercase + uppercase variants of single-letter words.
+ */
+const ORPHAN_REGEX = /(?<=\s|^)([iIwWzZoOuUaAeE]) (?=\S)/g;
+/**
+ * Replace regular space after single-letter Polish conjunctions with non-breaking space.
+ * Idempotent — already-fixed text (with \u00A0) is not modified.
+ */
+export function fixOrphans(text) {
+    return text.replace(ORPHAN_REGEX, '$1\u00A0');
+}

package/dist/core/server/fields/utils/imageStyles.d.ts

@@ -1,10 +1,12 @@
-import type { ImageField, ImageFieldStyle } from '../../../../types/fields.js';
+import type { ImageFieldStyle } from '../../../../types/fields.js';
 import type { ImageStyle, MediaFile } from '../../../../types/media.js';
 export declare const defaultStyles: ImageFieldStyle[];
 export declare function getOriginalFormat(val: MediaFile): string;
 export declare function expandStyleFormats(styles: ImageFieldStyle[], originalFormat?: string): ImageFieldStyle[];
 export declare function isProcessableImage(val: MediaFile): boolean;
-export declare function getImageStyles(field: ImageField, val: MediaFile): Promise<{
+export declare function getImageStyles(field: {
+    styles?: ImageFieldStyle[];
+}, val: MediaFile): Promise<{
     styles: Record<string, ImageStyle>;
     blurDataUrl: string | null;
 }>;