includio-cms 0.25.0 → 0.26.0

package/dist/admin/i18n/errors.js

@@ -0,0 +1,151 @@
+/**
+ * AriaCMS — Error message catalog (COGA-friendly, PL/EN).
+ *
+ * Tone-of-voice (zob. `src/stories/docs/tone-of-voice.mdx`):
+ * - Mów do użytkownika, nie o nim
+ * - Konkretnie + akcja co zrobić, nie sucha diagnoza
+ * - Bez żargonu, kodów HTTP, "UWAGA!", "Validation failed"
+ * - Bez strachu — prowadź, nie strasz
+ *
+ * Wzorzec: "Brak/Problem X — zrób Y, żeby Z."
+ *
+ * `@public` od v0.26.0. Migracja do paraglide w S10.
+ */
+export const errorMessages = {
+    validation: {
+        required: {
+            pl: "Wpisz to pole, żeby zapisać.",
+            en: "Fill in this field to save.",
+        },
+        invalidEmail: {
+            pl: "Sprawdź email — wygląda jakby brakowało @ i domeny.",
+            en: "Check the email — looks like @ or domain is missing.",
+        },
+        minLength: (n) => ({
+            pl: `Wpisz przynajmniej ${n} ${pluralPL(n, "znak", "znaki", "znaków")}.`,
+            en: `Use at least ${n} character${n === 1 ? "" : "s"}.`,
+        }),
+        passwordWeak: {
+            pl: "Hasło musi mieć wielką literę, cyfrę i znak specjalny — to chroni twoje konto.",
+            en: "Password needs an uppercase letter, a digit and a special character — for your account safety.",
+        },
+        passwordsDoNotMatch: {
+            pl: "Hasła się różnią — wpisz to samo w obu polach.",
+            en: "Passwords don't match — type the same one in both fields.",
+        },
+        invalidFormat: {
+            pl: "Sprawdź wpisaną wartość — format wygląda na inny niż oczekiwany.",
+            en: "Check the value — the format looks unexpected.",
+        },
+    },
+    network: {
+        offline: {
+            pl: "Brak połączenia z internetem — sprawdź sieć i spróbuj ponownie.",
+            en: "No internet connection — check your network and try again.",
+        },
+        timeout: {
+            pl: "Serwer odpowiada wolno — spróbuj jeszcze raz za chwilę.",
+            en: "The server is slow to respond — try again in a moment.",
+        },
+        generic: {
+            pl: "Nie udało się połączyć — spróbuj jeszcze raz.",
+            en: "Couldn't connect — try again.",
+        },
+    },
+    permission: {
+        denied: {
+            pl: "Nie masz dostępu do tego działania — poproś administratora o uprawnienia.",
+            en: "You don't have access to this action — ask an admin for permissions.",
+        },
+        sessionExpired: {
+            pl: "Sesja wygasła — zaloguj się ponownie, żeby kontynuować.",
+            en: "Your session expired — sign in again to continue.",
+        },
+    },
+    conflict: {
+        nameTaken: {
+            pl: "Ta nazwa jest już zajęta — wybierz inną.",
+            en: "That name is already taken — pick a different one.",
+        },
+        alreadyExists: {
+            pl: "Taki wpis już istnieje — sprawdź czy nie tworzysz duplikatu.",
+            en: "An item like this already exists — check that you're not duplicating it.",
+        },
+        staleData: {
+            pl: "Ktoś zaktualizował te dane — odśwież stronę i wprowadź zmiany ponownie.",
+            en: "Someone updated this data — refresh the page and try again.",
+        },
+    },
+    server: {
+        saveFailed: {
+            pl: "Nie udało się zapisać — spróbuj jeszcze raz.",
+            en: "Couldn't save — try again.",
+        },
+        loadFailed: {
+            pl: "Nie udało się wczytać danych — odśwież stronę.",
+            en: "Couldn't load the data — refresh the page.",
+        },
+        uploadFailed: {
+            pl: "Nie udało się przesłać pliku — spróbuj jeszcze raz.",
+            en: "Couldn't upload the file — try again.",
+        },
+        generic: {
+            pl: "Coś poszło nie tak — spróbuj jeszcze raz.",
+            en: "Something went wrong — try again.",
+        },
+    },
+    upload: {
+        fileTooLarge: (maxMB) => ({
+            pl: `Plik za duży — maksymalnie ${maxMB} MB. Spróbuj go skompresować.`,
+            en: `File too large — max ${maxMB} MB. Try compressing it.`,
+        }),
+        unsupportedType: {
+            pl: "Ten format nie jest obsługiwany — wybierz inny plik.",
+            en: "This format isn't supported — pick a different file.",
+        },
+    },
+    notFound: {
+        entry: {
+            pl: "Nie znaleziono wpisu — mógł zostać usunięty lub przeniesiony.",
+            en: "Entry not found — it may have been deleted or moved.",
+        },
+        page: {
+            pl: "Nie znaleziono strony — sprawdź adres lub wróć do panelu.",
+            en: "Page not found — check the address or return to the dashboard.",
+        },
+    },
+};
+export const successMessages = {
+    saved: {
+        pl: "Zapisano.",
+        en: "Saved.",
+    },
+    published: {
+        pl: "Opublikowano — zmiany są już widoczne na stronie.",
+        en: "Published — changes are now live.",
+    },
+    uploaded: {
+        pl: "Plik przesłany.",
+        en: "File uploaded.",
+    },
+    deleted: {
+        pl: "Usunięto.",
+        en: "Deleted.",
+    },
+};
+/**
+ * Pobierz zlokalizowany komunikat dla interfejsu.
+ * @example pickError(errorMessages.server.saveFailed, lang.current)
+ */
+export function pickError(msg, lang) {
+    return msg[lang];
+}
+function pluralPL(n, singular, few, many) {
+    const mod10 = n % 10;
+    const mod100 = n % 100;
+    if (n === 1)
+        return singular;
+    if (mod10 >= 2 && mod10 <= 4 && (mod100 < 10 || mod100 >= 20))
+        return few;
+    return many;
+}

package/dist/admin/remote/entry.remote.d.ts

@@ -1,3 +1,4 @@
+import type { Localized } from '../../types/languages.js';
 import { type RawEntry } from '../../types/entries.js';
 export declare const getRawEntries: import("@sveltejs/kit").RemoteQueryFunction<{
     ids?: string[] | undefined;
@@ -25,12 +26,30 @@ export declare const getEntries: import("@sveltejs/kit").RemoteQueryFunction<{
         direction: "asc" | "desc";
     } | undefined;
 }, import("../../types/entries.js").Entry[]>;
+/**
+ * Cross-collection search for the URL field's internal-link picker. Matches
+ * the term (case-insensitive, OR) against each collection's admin-title field
+ * (`entryAdminTitle`), its `slug`-type field, and `seo.slug` / `seo.title`.
+ * The previous `getEntries({ dataLike })` call was a no-op because it never
+ * passed a collection slug (`if (!input.slug) return []`).
+ */
+export declare const searchLinkableEntries: import("@sveltejs/kit").RemoteQueryFunction<{
+    term: string;
+    language?: string | undefined;
+}, {
+    _id: string;
+    _slug: string;
+    _url?: string;
+    title: string;
+    slug: string;
+}[]>;
 export declare const getEntryLabels: import("@sveltejs/kit").RemoteQueryFunction<{
     slug: string;
     ids?: string[] | undefined;
     search?: string | undefined;
     limit?: number | undefined;
     status?: "draft" | "published" | "all" | undefined;
+    language?: string | undefined;
 }, {
     id: string;
     label: string;
@@ -58,7 +77,7 @@ export declare const updateEntryVersionCommand: import("@sveltejs/kit").RemoteCo
     entryId: string;
     lang: string;
     data: Record<string, unknown>;
-    type: "draft" | "published-now" | "published-scheduled" | "cancel-published";
+    type: "draft" | "published-now" | "published-scheduled" | "cancel-published" | "cancel-scheduled";
     scheduledAt?: Date | undefined;
 }, Promise<import("../../types/entries.js").DbEntryVersion | undefined>>;
 export declare const updateEntryCommand: import("@sveltejs/kit").RemoteCommand<{
@@ -79,18 +98,54 @@ export declare const getEntryVersion: import("@sveltejs/kit").RemoteQueryFunctio
     id: string;
     language: string;
 }, import("../../types/entries.js").Entry | null>;
-export declare const getRecentEntries: import("@sveltejs/kit").RemoteQueryFunction<number | undefined, {
+/**
+ * `containerLabel` carries the collection's plural label for collection entries
+ * and the single's name for singles; clients localise it. For collection entries
+ * `label` is the entry's own title (or `null` to fall back to the slug); for
+ * singles `label` is always `null` — the title shown is `containerLabel`.
+ */
+export declare const getRecentEntries: import("@sveltejs/kit").RemoteQueryFunction<{
+    language: string;
+    limit?: number | undefined;
+}, {
     entryId: string;
     slug: string;
-    collectionLabel: Record<string, string>;
+    kind: "collection" | "single";
+    containerLabel: Localized;
     label: string | null;
+    labelLanguage: string | null;
     status: "draft" | "published" | "scheduled";
     updatedAt: Date;
 }[]>;
-export declare const getRecentActivity: import("@sveltejs/kit").RemoteQueryFunction<number | undefined, {
+export declare const getRecentActivity: import("@sveltejs/kit").RemoteQueryFunction<{
+    language: string;
+    limit?: number | undefined;
+}, {
     type: "entry_edit";
     entryId: string;
     slug: string;
+    kind: "collection" | "single";
     label: string | null;
+    labelLanguage: string | null;
+    containerLabel: Localized;
+    editorId: string | null;
+    editorName: string | null;
     updatedAt: Date;
 }[]>;
+/**
+ * Global quick-search over entry titles plus single names. Titles are matched
+ * and returned in the requested `language`, falling back to any available
+ * translation (`titleLanguage` reports which one was used). Used by the sidebar
+ * command palette. A full multi-language FTS search is tracked separately.
+ */
+export declare const searchEntries: import("@sveltejs/kit").RemoteQueryFunction<{
+    query: string;
+    language: string;
+}, {
+    entryId: string;
+    title: string;
+    titleLanguage: string | null;
+    kind: "collection" | "single";
+    containerSlug: string;
+    containerLabel: Localized;
+}[]>;

package/dist/admin/remote/entry.remote.js

@@ -1,10 +1,16 @@
 import { command, query } from '$app/server';
-import { getAtPath } from '../utils/objectPath.js';
+import { error } from '@sveltejs/kit';
+import { CmsError } from '../../core/errors.js';
+import { getRawCollectionEntryLabelWithLanguage } from '../utils/entryLabel.js';
+import { db } from '../../server/db/index.js';
+import { user } from '../../server/db/schema/auth-schema.js';
+import { inArray } from 'drizzle-orm';
 import { createEntry as createEntryOperation, createEntrySchema, createEntryVersion } from '../../core/server/entries/operations/create.js';
 import { _getRawEntries as getRawEntriesOperation, _countRawEntries as countRawEntriesOperation, _getRawEntry as getRawEntryOperation, _getRawEntryOrThrow as getRawEntryOrThrow, _getDbEntry as getDbEntry, getEntryVersion as getEntryVersionOperation, getEntryLabels as getEntryLabelsOperation } from '../../core/server/entries/operations/get.js';
 import { resolveEntries, resolveEntry } from '../../core/server/entries/operations/resolveEntry.js';
 import { getCMS } from '../../core/cms.js';
-import { pruneOldDraftVersions, unpublishEntryLang, upsertDraftVersion, updateEntry, updateEntrySchema, updateEntryVersionCommandTypes } from '../../core/server/entries/operations/update.js';
+import { getFieldsFromConfig } from '../../core/fields/layoutUtils.js';
+import { pruneOldDraftVersions, unpublishEntryLang, cancelScheduledEntryLang, upsertDraftVersion, updateEntry, updateEntrySchema, updateEntryVersionCommandTypes } from '../../core/server/entries/operations/update.js';
 import z from 'zod';
 import { requireAuth } from './middleware/auth.js';
 import { stableSlotReorder } from './reorder.js';
@@ -55,12 +61,84 @@ export const getEntries = query(z.object({
         orderBy: input.orderBy
     });
 });
+/**
+ * Cross-collection search for the URL field's internal-link picker. Matches
+ * the term (case-insensitive, OR) against each collection's admin-title field
+ * (`entryAdminTitle`), its `slug`-type field, and `seo.slug` / `seo.title`.
+ * The previous `getEntries({ dataLike })` call was a no-op because it never
+ * passed a collection slug (`if (!input.slug) return []`).
+ */
+export const searchLinkableEntries = query(z.object({ term: z.string(), language: z.string().optional() }), async ({ term, language }) => {
+    requireAuth();
+    const q = term.trim();
+    if (q.length < 2)
+        return [];
+    const cms = getCMS();
+    // Internal links are language-agnostic (resolved by id at render), but
+    // resolveEntries is strict per locale — so an entry that only has a
+    // `pl` version is invisible when searching the default `en`. Scan all
+    // languages (preferred one first) and dedupe by entry id.
+    const langs = [
+        ...(language ? [language] : []),
+        ...cms.languages.filter((l) => l !== language)
+    ];
+    const results = [];
+    for (const config of Object.values(cms.collections)) {
+        if (config.type !== 'collection')
+            continue;
+        const fields = getFieldsFromConfig(config);
+        const titleField = config.entryAdminTitle;
+        const slugField = fields.find((f) => f.type === 'slug')?.slug;
+        const ilike = { seo: { slug: q, title: q } };
+        if (titleField)
+            ilike[titleField] = q;
+        if (slugField)
+            ilike[slugField] = q;
+        for (const locale of langs) {
+            let entries;
+            try {
+                entries = await resolveEntries({
+                    collection: config.slug,
+                    locale,
+                    status: 'published',
+                    filter: { dataILikeOr: ilike }
+                });
+            }
+            catch {
+                continue;
+            }
+            for (const e of entries) {
+                const seo = e.seo;
+                const rawTitle = titleField ? e[titleField] : undefined;
+                const title = (typeof rawTitle === 'string' && rawTitle) ||
+                    (typeof seo?.title === 'string' && seo.title) ||
+                    '';
+                const rawSlug = slugField ? e[slugField] : undefined;
+                const slug = (typeof rawSlug === 'string' && rawSlug) ||
+                    (typeof seo?.slug === 'string' && seo.slug) ||
+                    '';
+                results.push({
+                    _id: e._id,
+                    _slug: config.slug,
+                    _url: typeof e._url === 'string' ? e._url : undefined,
+                    title,
+                    slug
+                });
+            }
+        }
+    }
+    const seen = new Set();
+    return results
+        .filter((r) => (seen.has(r._id) ? false : (seen.add(r._id), true)))
+        .slice(0, 8);
+});
 export const getEntryLabels = query(z.object({
     slug: z.string(),
     ids: z.array(z.string().uuid()).optional(),
     search: z.string().optional(),
     limit: z.number().int().positive().optional(),
-    status: z.enum(['published', 'draft', 'all']).optional()
+    status: z.enum(['published', 'draft', 'all']).optional(),
+    language: z.string().optional()
 }), async (input) => {
     return getEntryLabelsOperation(input);
 });
@@ -128,37 +206,51 @@ const updateEntryVersionCommandSchema = z.object({
 export const updateEntryVersionCommand = command(updateEntryVersionCommandSchema, async (input) => {
     const { user } = requireAuth();
     let result;
-    switch (input.type) {
-        case 'draft':
-            result = await upsertDraftVersion(input.entryId, input.data, input.lang, { skipValidation: true });
-            break;
-        case 'published-now': {
-            // Create a new published version for this language
-            result = await createEntryVersion({
+    // Publish failures should reach the client with a structured body so the
+    // editor can pin the message to the offending field. SvelteKit hides any
+    // thrown error that isn't created via `error()`, so wrap publish writes.
+    const runPublish = async (publishedAt) => {
+        try {
+            return await createEntryVersion({
                 entryId: input.entryId,
                 lang: input.lang,
                 data: input.data,
-                publishedAt: new Date(),
+                publishedAt,
                 publishedBy: user.id
             });
+        }
+        catch (e) {
+            if (e instanceof CmsError && e.code === 'SLUG_DUPLICATE') {
+                error(409, {
+                    message: e.message,
+                    code: e.code,
+                    path: typeof e.context.path === 'string' ? e.context.path : undefined
+                });
+            }
+            throw e;
+        }
+    };
+    switch (input.type) {
+        case 'draft':
+            result = await upsertDraftVersion(input.entryId, input.data, input.lang, { skipValidation: true });
+            break;
+        case 'published-now': {
+            result = await runPublish(new Date());
             break;
         }
         case 'published-scheduled': {
             if (!input.scheduledAt) {
                 throw new Error('scheduledAt is required for scheduled publishing');
             }
-            result = await createEntryVersion({
-                entryId: input.entryId,
-                lang: input.lang,
-                data: input.data,
-                publishedAt: input.scheduledAt,
-                publishedBy: user.id
-            });
+            result = await runPublish(input.scheduledAt);
             break;
         }
         case 'cancel-published':
             await unpublishEntryLang(input.entryId, input.lang);
             break;
+        case 'cancel-scheduled':
+            await cancelScheduledEntryLang(input.entryId, input.lang);
+            break;
     }
     // Prune old draft versions only after publish/schedule (drafts upsert in-place)
     if (input.type !== 'draft') {
@@ -210,7 +302,13 @@ export const getEntryVersion = query(z.object({
 }), async (input) => {
     return getEntryVersionOperation(input);
 });
-export const getRecentEntries = query(z.number().default(6), async (limit) => {
+/**
+ * `containerLabel` carries the collection's plural label for collection entries
+ * and the single's name for singles; clients localise it. For collection entries
+ * `label` is the entry's own title (or `null` to fall back to the slug); for
+ * singles `label` is always `null` — the title shown is `containerLabel`.
+ */
+export const getRecentEntries = query(z.object({ limit: z.number().default(6), language: z.string() }), async ({ limit, language }) => {
     const entries = await getRawEntriesOperation({
         orderBy: { column: 'updatedAt', direction: 'desc' },
         limit
@@ -223,30 +321,22 @@ export const getRecentEntries = query(z.number().default(6), async (limit) => {
         catch {
             // orphaned entry
         }
-        const latestVersion = entry.versions[0];
+        const kind = config?.type === 'single' ? 'single' : 'collection';
         let label = null;
-        if (config && config.type === 'collection' && config.entryAdminTitle && latestVersion) {
-            const titleData = getAtPath(latestVersion.data, config.entryAdminTitle);
-            if (typeof titleData === 'string') {
-                label = titleData || '';
+        let labelLanguage = null;
+        if (config && config.type === 'collection') {
+            const resolved = getRawCollectionEntryLabelWithLanguage(entry, config, language);
+            if (resolved.label !== entry.id) {
+                label = resolved.label;
+                labelLanguage = resolved.language;
             }
         }
-        if (config && config.type === 'single' && config.label) {
-            if (typeof config.label === 'object') {
-                label = String(Object.values(config.label)[0] || '');
-            }
-            else {
-                label = config.label;
-            }
+        let containerLabel = { pl: entry.slug, en: entry.slug };
+        if (config?.type === 'collection' && config.labels) {
+            containerLabel = config.labels.plural ?? config.labels.singular ?? containerLabel;
         }
-        let collectionLabel = { pl: entry.slug, en: entry.slug };
-        if (config) {
-            if (config.type === 'collection' && config.labels) {
-                collectionLabel = config.labels.plural ?? config.labels.singular ?? collectionLabel;
-            }
-            else if (config.type === 'single' && config.label) {
-                collectionLabel = config.label;
-            }
+        else if (config?.type === 'single' && config.label) {
+            containerLabel = config.label;
         }
         const hasPublished = Object.values(entry.publishedVersions).some((v) => v != null);
         const hasScheduled = Object.values(entry.scheduledVersions).some((v) => v != null);
@@ -258,43 +348,130 @@ export const getRecentEntries = query(z.number().default(6), async (limit) => {
         return {
             entryId: entry.id,
             slug: entry.slug,
-            collectionLabel,
+            kind,
+            containerLabel,
             label,
+            labelLanguage,
             status,
             updatedAt: entry.updatedAt
         };
     });
 });
-export const getRecentActivity = query(z.number().default(10), async (limit) => {
+export const getRecentActivity = query(z.object({ limit: z.number().default(10), language: z.string() }), async ({ limit, language }) => {
     const entries = await getRawEntriesOperation({});
     const activity = [];
     for (const entry of entries) {
         const latestVersion = entry.versions[0];
-        if (latestVersion) {
-            const config = getCMS().getBySlug(entry.slug);
-            let label = null;
-            if (config && config.type === 'collection' && config.entryAdminTitle) {
-                const titleData = getAtPath(latestVersion.data, config.entryAdminTitle);
-                if (typeof titleData === 'string') {
-                    label = titleData || null;
-                }
+        if (!latestVersion)
+            continue;
+        let config = null;
+        try {
+            config = getCMS().getBySlug(entry.slug);
+        }
+        catch {
+            // orphaned entry — still surface the edit, just without a friendly label
+        }
+        const kind = config?.type === 'single' ? 'single' : 'collection';
+        let label = null;
+        let labelLanguage = null;
+        let containerLabel = { pl: entry.slug, en: entry.slug };
+        if (config && config.type === 'collection') {
+            const resolved = getRawCollectionEntryLabelWithLanguage(entry, config, language);
+            if (resolved.label !== entry.id) {
+                label = resolved.label;
+                labelLanguage = resolved.language;
             }
-            if (config && config.type === 'single' && config.label) {
-                if (typeof config.label === 'object') {
-                    label = String(Object.values(config.label)[0] || '');
-                }
-                else {
-                    label = config.label;
-                }
+            if (config.labels) {
+                containerLabel = config.labels.singular ?? config.labels.plural ?? containerLabel;
             }
-            activity.push({
-                type: 'entry_edit',
+        }
+        else if (config?.type === 'single' && config.label) {
+            containerLabel = config.label;
+        }
+        activity.push({
+            type: 'entry_edit',
+            entryId: entry.id,
+            slug: entry.slug,
+            kind,
+            label,
+            labelLanguage,
+            containerLabel,
+            editorId: latestVersion.createdBy ?? null,
+            editorName: null,
+            updatedAt: latestVersion.createdAt
+        });
+    }
+    const recent = activity
+        .sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime())
+        .slice(0, limit);
+    // resolve editor names for the items we're returning
+    const editorIds = [...new Set(recent.map((a) => a.editorId).filter((id) => !!id))];
+    if (editorIds.length > 0) {
+        const rows = await db
+            .select({ id: user.id, name: user.name })
+            .from(user)
+            .where(inArray(user.id, editorIds));
+        const nameById = new Map(rows.map((r) => [r.id, r.name]));
+        for (const item of recent) {
+            if (item.editorId)
+                item.editorName = nameById.get(item.editorId) ?? null;
+        }
+    }
+    return recent;
+});
+/**
+ * Global quick-search over entry titles plus single names. Titles are matched
+ * and returned in the requested `language`, falling back to any available
+ * translation (`titleLanguage` reports which one was used). Used by the sidebar
+ * command palette. A full multi-language FTS search is tracked separately.
+ */
+export const searchEntries = query(z.object({ query: z.string(), language: z.string() }), async ({ query: rawQuery, language }) => {
+    requireAuth();
+    const q = rawQuery.trim();
+    if (q.length < 2)
+        return [];
+    const cms = getCMS();
+    const needle = q.toLocaleLowerCase();
+    const results = [];
+    for (const config of Object.values(cms.collections)) {
+        const containerLabel = config.labels?.plural ?? config.labels?.singular ?? { pl: config.slug, en: config.slug };
+        const entries = await getRawEntriesOperation({ slug: config.slug });
+        for (const entry of entries) {
+            const resolved = getRawCollectionEntryLabelWithLanguage(entry, config, language);
+            if (resolved.label === entry.id)
+                continue; // no usable title
+            if (!resolved.label.toLocaleLowerCase().includes(needle))
+                continue;
+            results.push({
                 entryId: entry.id,
-                slug: entry.slug,
-                label,
-                updatedAt: latestVersion.createdAt
+                title: resolved.label,
+                titleLanguage: resolved.language,
+                kind: 'collection',
+                containerSlug: config.slug,
+                containerLabel
             });
         }
     }
-    return activity.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime()).slice(0, limit);
+    for (const config of Object.values(cms.singles)) {
+        const labelObj = config.label;
+        const names = labelObj && typeof labelObj === 'object' ? Object.values(labelObj) : labelObj ? [labelObj] : [];
+        const matches = config.slug.toLocaleLowerCase().includes(needle) ||
+            names.some((n) => typeof n === 'string' && n.toLocaleLowerCase().includes(needle));
+        if (!matches)
+            continue;
+        const localizedTitle = labelObj && typeof labelObj === 'object' ? labelObj[language] : undefined;
+        const title = localizedTitle ??
+            (labelObj && typeof labelObj === 'object'
+                ? (Object.values(labelObj)[0] ?? config.slug)
+                : labelObj || config.slug);
+        results.push({
+            entryId: config.slug,
+            title,
+            titleLanguage: localizedTitle ? language : null,
+            kind: 'single',
+            containerSlug: config.slug,
+            containerLabel: labelObj && typeof labelObj === 'object' ? labelObj : { pl: title, en: title }
+        });
+    }
+    return results.slice(0, 20);
 });