@vectoriox/iox-ui 5.68.0 → 5.69.0

package/generation-core/index.d.ts

@@ -69,6 +69,7 @@ declare const SPEC_SITE_PLAN_SHAPE: {
         readonly count: "integer ≥ 0";
         readonly sample: "boolean — items are flagged isSample";
         readonly isPublished: "boolean";
+        readonly "perItem?": "per field, one string per sample: real content that wins over the template";
         readonly "[field]?": "the field's value — strings are templates: {n} = the item's 1-based number, {sampleImage:n} / {sampleImage:n+k} = a bundled sample image";
     };
     readonly cmsDataSource: {
@@ -4371,6 +4372,8 @@ interface ContentSeedPlan {
     readonly count: number;
     readonly sample: boolean;
     readonly isPublished: boolean;
+    /** Per field, one value per sample: real content where the items are about a subject anyone can know. Wins over the field's template. */
+    readonly perItem?: Readonly<Record<string, ReadonlyArray<string>>>;
     readonly [field: string]: unknown;
 }
 /** The part a field plays (contract `site.roles`, AI plan L0-3): what a pattern binds instead of a field name, so one

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vectoriox/iox-ui",
-  "version": "5.68.0",
+  "version": "5.69.0",
   "peerDependencies": {
     "@angular/common": ">=20.0.0",
     "@angular/core": ">=20.0.0",

package/src/generation-core/compose-site.ts

@@ -1109,7 +1109,8 @@ function composeItems(type: ContentTypePlan, fillEmpty: boolean): ComposedItem[]
         for (const field of type.fields) {
             const given = seed[field.name];
             const empty = !(field.name in seed) || given === '' || (Array.isArray(given) && !given.length);
-            const value = empty && fillEmpty ? defaultSeed(type, field) : given;
+            const own = seed.perItem?.[field.name]?.[n - 1];
+            const value = own || (empty && fillEmpty ? defaultSeed(type, field) : given);
             if (value !== undefined) item[field.name] = expandSeedValue(value, n);
         }
         items.push({ ...item, isPublished: seed.isPublished, isSample: seed.sample });

package/src/generation-core/plan-wire.ts

@@ -130,6 +130,7 @@ const WIRE_KEYS: Readonly<Record<`${PlanWireEntry}`, Readonly<Record<string, Wir
     seedValue: {
         field: { refs: ['seed.[field]'], text: 'string — a field of the type' },
         value: { refs: ['seed.[field]'], text: `string | string[] — ${describeShapeKey(PLAN_SHAPE['seed'], '[field]')} (a list for an array field)` },
+        each: { refs: ['seed.perItem'], text: 'string[] — one value per sample, in order, when each sample has its own content', none: '[]' },
     },
     dataSource: {
         alias: { refs: ['cmsDataSource.alias', 'relativeDataSource.alias'] },
@@ -284,7 +285,7 @@ const shapedAs = (entry: `${PlanWireEntry}`, options: WireOptions, properties: R
 };
 
 export function wireContentTypeJsonSchema(options: WireOptions = {}): JsonSchema {
-    const value = shaped(PlanWireEntry.SeedValue, { field: jsonText(), value: jsonAnyOf([jsonText(), jsonListOf(jsonText())]) });
+    const value = shaped(PlanWireEntry.SeedValue, { field: jsonText(), value: jsonAnyOf([jsonText(), jsonListOf(jsonText())]), each: jsonListOf(jsonText()) });
     return shapedAs(PlanWireEntry.ContentType, options, {
         name: jsonText(),
         label: jsonText(),
@@ -412,8 +413,16 @@ export function expandWireContentType(wire: unknown, options: WireOptions = {}):
     if (!isPlainObject(seed)) return seed === undefined ? out : { ...out, seed };
     const { values, ...fixed } = seed;
     if (fixed['count'] === 0 && emptyList(values)) return out;
-    const map = listToMap(values ?? [], 'field', 'value');
-    return { ...out, seed: isPlainObject(map) ? { ...fixed, ...map } : { ...fixed, values } };
+    const perItem: Record<string, unknown> = {};
+    const plain = Array.isArray(values) ? values.map(row => {
+        if (!isPlainObject(row)) return row;
+        const { each, ...rest } = row;
+        if (Array.isArray(each) && each.length) perItem[String(rest['field'])] = each;
+        return rest;
+    }) : values;
+    const map = listToMap(plain ?? [], 'field', 'value');
+    const items = Object.keys(perItem).length ? { perItem } : {};
+    return { ...out, seed: isPlainObject(map) ? { ...fixed, ...items, ...map } : { ...fixed, values } };
 }
 
 export function expandWireDataSource(wire: unknown): DataSourcePlan | unknown {
@@ -501,10 +510,10 @@ export function fieldToWire(field: ContentFieldPlan): PlainObject {
 export function contentTypeToWire(type: ContentTypePlan, options: WireOptions = {}): PlainObject {
     const played = type.roles as Readonly<Record<string, string | undefined>>;
     const roles = ROLE_KEYS.filter(role => played[role]).map(role => ({ role, field: played[role] }));
-    const { count = 0, sample = false, isPublished = false, ...values } = type.seed ?? {};
+    const { count = 0, sample = false, isPublished = false, perItem = {}, ...values } = type.seed ?? {};
     return {
         name: type.name, label: type.label, roles, ...(options.children === false ? {} : { fields: type.fields.map(fieldToWire) }),
-        seed: { count, sample, isPublished, values: mapToList(values, 'field', 'value') },
+        seed: { count, sample, isPublished, values: mapToList(values, 'field', 'value').map(row => ({ ...row, each: perItem[String(row['field'])] ?? [] })) },
     };
 }
 

package/src/generation-core/plan-words.ts

@@ -45,7 +45,9 @@ export function writtenTexts(plan: SitePlan): WrittenText[] {
     });
     plan.contentTypes?.forEach((type, t) => {
         add(`contentTypes[${t}].label`, type.label);
-        for (const [field, value] of Object.entries(type.seed ?? {})) {
+        const { perItem, ...seed }: Record<string, unknown> & { perItem?: Readonly<Record<string, ReadonlyArray<string>>> } = type.seed ?? {};
+        for (const [field, list] of Object.entries(perItem ?? {})) list.forEach((v, k) => add(`contentTypes[${t}].seed.perItem.${field}[${k}]`, v));
+        for (const [field, value] of Object.entries(seed)) {
             const values = Array.isArray(value) ? value : [value];
             values.forEach((v, k) => add(`contentTypes[${t}].seed.${field}${Array.isArray(value) ? `[${k}]` : ''}`, v));
         }

package/src/generation-core/site-plan.model.ts

@@ -79,6 +79,8 @@ export interface ContentSeedPlan {
     readonly count: number;
     readonly sample: boolean;
     readonly isPublished: boolean;
+    /** Per field, one value per sample: real content where the items are about a subject anyone can know. Wins over the field's template. */
+    readonly perItem?: Readonly<Record<string, ReadonlyArray<string>>>;
     readonly [field: string]: unknown;
 }
 

package/src/generation-core/site-spec.generated.ts

@@ -69,6 +69,7 @@ export const SPEC_SITE_PLAN_SHAPE = {
     "count": "integer ≥ 0",
     "sample": "boolean — items are flagged isSample",
     "isPublished": "boolean",
+    "perItem?": "per field, one string per sample: real content that wins over the template",
     "[field]?": "the field's value — strings are templates: {n} = the item's 1-based number, {sampleImage:n} / {sampleImage:n+k} = a bundled sample image"
   },
   "cmsDataSource": {

package/src/generation-core/validate-site-plan.ts

@@ -103,6 +103,7 @@ const ROLE_KEYS = shapeKeys(SHAPE['roles']);
 const PAGE_SEO_KEYS = shapeKeys(SHAPE['pageSeo']);
 const ARRAY_TYPE = 'array';
 const FIELD_KEYS = shapeKeys(SHAPE['field']);
+const SLUG_FIELD = 'slug';
 const SEED_FIXED_KEYS = shapeKeys(SHAPE['seed']);
 const CMS_SOURCE_KEYS = shapeKeys(SHAPE['cmsDataSource']);
 const RELATIVE_SOURCE_KEYS = shapeKeys(SHAPE['relativeDataSource']);
@@ -226,6 +227,16 @@ function validateContentTypes(c: Collector, list: unknown[]): Map<string, Conten
             else {
                 if (!Number.isInteger(seed['count']) || (seed['count'] as number) < 0) c.add(SitePlanIssueCode.Shape, `${path}.seed.count`, 'must be a whole number');
                 for (const key of ['sample', 'isPublished']) if (typeof seed[key] !== 'boolean') c.add(SitePlanIssueCode.Shape, `${path}.seed.${key}`, 'must be a boolean');
+                const perItem = seed['perItem'];
+                if (perItem !== undefined) {
+                    if (!isObject(perItem)) c.add(SitePlanIssueCode.Shape, `${path}.seed.perItem`, 'must be an object');
+                    else for (const [field, list] of Object.entries(perItem)) {
+                        const at = `${path}.seed.perItem.${field}`;
+                        if (!fieldSet.has(field)) c.add(SitePlanIssueCode.UnknownField, at, `"${field}" is not a field of ${name}`);
+                        else if (!Array.isArray(list) || list.length !== seed['count'] || list.some(v => typeof v !== 'string')) c.add(SitePlanIssueCode.Shape, at, `must be ${String(seed['count'])} strings, one per sample`);
+                        else if (field === SLUG_FIELD && new Set(list).size !== list.length) c.add(SitePlanIssueCode.Shape, at, 'each sample needs its own slug');
+                    }
+                }
                 for (const key of Object.keys(seed)) {
                     if (!SEED_FIXED_KEYS.includes(key) && !fieldSet.has(key)) c.add(SitePlanIssueCode.UnknownField, `${path}.seed.${key}`, `"${key}" is not a field of ${name}`);
                 }