@contentful/experience-design-system-types 2.34.5-dev-build-d08439d.0 → 2.34.5-dev-build-75bf00ac.0

package/README.md

@@ -8,22 +8,16 @@ This package is a bundled dependency of `@contentful/experience-design-system-cl
 
 ### CDF — Component Definition Format
 
-Typed and validated structure for `.cdf.json` component definition files that describe a design system's component library.
+One typed, validated document for a design system's components and design tokens together — the request body sent to both the preview and apply endpoints. A leaf's `$type` decides what it is (`'component'` vs. a `DESIGN_TOKEN_TYPES` member), so groups can nest either kind side by side. There is no separate manifest envelope.
 
-**Exports:** `validateCDF`, `CDF_V1_SCHEMA_URL`, `CDF_PROPERTY_TYPES`, `CDFComponentEntry`, `CDFPropertyDefinition`, `CDFValidationError`
+**Exports:** `validateCDF`, `parseCDFComponents`, `buildCDF`, `buildFilteredCDF`, `validateSlotReferences`, `CDF_SCHEMA_URL`, `CDF_PROPERTY_TYPES`, `CDFComponentEntry`, `CDFTokenEntry`, `CDFPropertyDefinition`, `CDFValidationError`, `CDFValidationResult`, `CDFDocument`
 
 ### DTCG — Design Token Community Group
 
-Types for `.tokens.json` files following the [W3C DTCG format](https://tr.designtokens.org/format/) that describe a design system's token library.
+Types for standalone `.tokens.json` files following the [W3C DTCG format](https://tr.designtokens.org/format/) — used when generating or ingesting raw design tokens ahead of merging them into a CDF document.
 
 **Exports:** `DESIGN_TOKEN_TYPES`, `DesignTokenType`, `DTCGTokenEntry`, `DTCGTokenGroup`, `DTCGTokenNode`, `DTCGTokenGroupNode`
 
-### Sources API — Manifest
-
-Request body sent to both the preview and apply endpoints.
-
-**Exports:** `ManifestPayload`
-
 ### Sources API — Preview
 
 Response types for the Sources API preview endpoint, which returns a diff of what will change before committing.

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-types",
-  "version": "2.34.5-dev-build-d08439d.0",
+  "version": "2.34.5-dev-build-75bf00ac.0",
   "license": "MIT",
   "type": "module",
   "module": "./dist/src/index.js",

package/dist/src/cdf/build.d.ts

@@ -0,0 +1,43 @@
+import { CDF_SCHEMA_URL } from './schema.js';
+import type { CDFComponentEntry, CDFTokenEntry, CDFValidationError } from './types.js';
+/** Drops `$required` from slot definitions — the server never reads it and
+ * older CDF consumers reject unknown slot fields. */
+export declare function stripUnsupportedSlotFields(entry: CDFComponentEntry): CDFComponentEntry;
+/** A CDF document — the single file/wire payload for both components and
+ * design tokens. There is no separate manifest envelope. */
+export interface CDFDocument {
+    $schema: typeof CDF_SCHEMA_URL;
+    [key: string]: unknown;
+}
+export declare function buildCDF(components: Array<{
+    key: string;
+    entry: CDFComponentEntry;
+}>, tokens: Array<{
+    path: string;
+    entry: CDFTokenEntry;
+}>, opts?: {
+    deleteAll?: boolean;
+}): CDFDocument | undefined;
+/**
+ * Filters a CDF document down to a selected subset of component keys and
+ * token paths, preserving the group nesting each dotted path implies.
+ */
+export declare function buildFilteredCDF(fullDocument: CDFDocument, selectedComponentKeys: Set<string>, selectedTokenPaths: Set<string>): CDFDocument | undefined;
+/**
+ * Document-local pre-flight for `$allowedComponents` references: every entry
+ * must resolve to another component in the same document, or be left for the
+ * server to resolve against the target environment (this function has no
+ * network access, so it cannot tell "doesn't exist anywhere" from "exists
+ * only in the target env" — it only flags names absent from `components`).
+ *
+ * Mirrors the error shape `previewImport`/`applyImport` return for the
+ * equivalent server-side check, so callers can route both through the same
+ * `path`/`message` handling — just without a round-trip when the typo is
+ * local to the document itself. The `manifest:` path prefix below is a wire
+ * contract with the server's own error shape — keep it as-is even though the
+ * rest of this module no longer says "manifest".
+ */
+export declare function validateSlotReferences(components: Array<{
+    key: string;
+    entry: CDFComponentEntry;
+}>): CDFValidationError[];

package/dist/src/cdf/build.js

@@ -0,0 +1,98 @@
+import { CDF_SCHEMA_URL } from './schema.js';
+/** Drops `$required` from slot definitions — the server never reads it and
+ * older CDF consumers reject unknown slot fields. */
+export function stripUnsupportedSlotFields(entry) {
+    if (!entry.$slots)
+        return entry;
+    const cleaned = {};
+    for (const [name, slot] of Object.entries(entry.$slots)) {
+        const { $required: _required, ...rest } = slot;
+        cleaned[name] = rest;
+    }
+    return { ...entry, $slots: cleaned };
+}
+export function buildCDF(components, tokens, opts = {}) {
+    if (components.length === 0 && tokens.length === 0 && !opts.deleteAll)
+        return undefined;
+    const doc = { $schema: CDF_SCHEMA_URL };
+    for (const { key, entry } of components) {
+        setAtPath(doc, key, stripUnsupportedSlotFields(entry));
+    }
+    for (const { path, entry } of tokens) {
+        setAtPath(doc, path, entry);
+    }
+    return doc;
+}
+/**
+ * Filters a CDF document down to a selected subset of component keys and
+ * token paths, preserving the group nesting each dotted path implies.
+ */
+export function buildFilteredCDF(fullDocument, selectedComponentKeys, selectedTokenPaths) {
+    const selected = new Set([...selectedComponentKeys, ...selectedTokenPaths]);
+    if (selected.size === 0)
+        return undefined;
+    const filtered = { $schema: CDF_SCHEMA_URL };
+    for (const dottedPath of selected) {
+        const value = getAtPath(fullDocument, dottedPath);
+        if (value !== undefined)
+            setAtPath(filtered, dottedPath, value);
+    }
+    return filtered;
+}
+/**
+ * Document-local pre-flight for `$allowedComponents` references: every entry
+ * must resolve to another component in the same document, or be left for the
+ * server to resolve against the target environment (this function has no
+ * network access, so it cannot tell "doesn't exist anywhere" from "exists
+ * only in the target env" — it only flags names absent from `components`).
+ *
+ * Mirrors the error shape `previewImport`/`applyImport` return for the
+ * equivalent server-side check, so callers can route both through the same
+ * `path`/`message` handling — just without a round-trip when the typo is
+ * local to the document itself. The `manifest:` path prefix below is a wire
+ * contract with the server's own error shape — keep it as-is even though the
+ * rest of this module no longer says "manifest".
+ */
+export function validateSlotReferences(components) {
+    const componentKeys = new Set(components.map((c) => c.key));
+    const errors = [];
+    for (const { key, entry } of components) {
+        const slots = entry.$slots ?? {};
+        for (const [slotKey, slot] of Object.entries(slots)) {
+            const allowed = slot?.$allowedComponents ?? [];
+            const unresolved = allowed.filter((name) => !componentKeys.has(name));
+            if (unresolved.length === 0)
+                continue;
+            errors.push({
+                path: `manifest:components/${key}/$slots/${slotKey}/$allowedComponents`,
+                message: `Unresolved $allowedComponents reference(s): ${unresolved.join(', ')}. ` +
+                    `Not found in this document — if not an existing Component in the target ` +
+                    `environment either, the server will reject this on preview/apply.`,
+            });
+        }
+    }
+    return errors;
+}
+function setAtPath(root, dottedPath, value) {
+    const segments = dottedPath.split('.');
+    let cursor = root;
+    for (let i = 0; i < segments.length - 1; i += 1) {
+        const segment = segments[i];
+        const next = cursor[segment];
+        if (typeof next !== 'object' || next === null) {
+            cursor[segment] = {};
+        }
+        cursor = cursor[segment];
+    }
+    cursor[segments[segments.length - 1]] = value;
+}
+function getAtPath(root, dottedPath) {
+    const segments = dottedPath.split('.');
+    let cursor = root;
+    for (const segment of segments) {
+        if (typeof cursor !== 'object' || cursor === null)
+            return undefined;
+        cursor = cursor[segment];
+    }
+    return cursor;
+}

package/dist/src/cdf/index.d.ts

@@ -1,4 +1,5 @@
 export { validateCDF, parseCDFComponents } from './validate.js';
-export { CDF_V1_SCHEMA_URL } from './schema.js';
+export { CDF_SCHEMA_URL, cdfJsonSchema } from './schema.js';
 export { CDF_PROPERTY_TYPES, CDF_PROPERTY_CATEGORIES } from './vocabularies.js';
-export { CDFComponentSchema, CDFPropertySchema, CDFSlotSchema, type CDFComponentEntry, type CDFPropertyDefinition, type CDFSlotDefinition, type CDFValidationError, } from './types.js';
+export { CDFComponentSchema, CDFPropertySchema, CDFSlotSchema, CDFTokenSchema, type CDFComponentEntry, type CDFPropertyDefinition, type CDFSlotDefinition, type CDFTokenEntry, type CDFValidationError, type CDFValidationResult, } from './types.js';
+export { buildCDF, buildFilteredCDF, stripUnsupportedSlotFields, validateSlotReferences, type CDFDocument, } from './build.js';

package/dist/src/cdf/index.js

@@ -1,4 +1,5 @@
 export { validateCDF, parseCDFComponents } from './validate.js';
-export { CDF_V1_SCHEMA_URL } from './schema.js';
+export { CDF_SCHEMA_URL, cdfJsonSchema } from './schema.js';
 export { CDF_PROPERTY_TYPES, CDF_PROPERTY_CATEGORIES } from './vocabularies.js';
-export { CDFComponentSchema, CDFPropertySchema, CDFSlotSchema, } from './types.js';
+export { CDFComponentSchema, CDFPropertySchema, CDFSlotSchema, CDFTokenSchema, } from './types.js';
+export { buildCDF, buildFilteredCDF, stripUnsupportedSlotFields, validateSlotReferences, } from './build.js';

package/dist/src/cdf/schema.d.ts

@@ -1,23 +1,32 @@
-export declare const CDF_V1_SCHEMA_URL = "https://contentful.com/schemas/cdf/v1";
-export declare const cdfV1JsonSchema: {
+export declare const CDF_SCHEMA_URL = "https://contentful.com/schemas/cdf";
+/**
+ * Components and design tokens live in one recursive tree. A leaf's `$type`
+ * decides what it is ('component' vs. a DESIGN_TOKEN_TYPES member), so the
+ * same `group` container can hold either kind side by side. There is no
+ * separate manifest envelope — this document is the single file/wire
+ * payload sent to preview/apply.
+ */
+export declare const cdfJsonSchema: {
     readonly $schema: "http://json-schema.org/draft-07/schema#";
-    readonly $id: "https://contentful.com/schemas/cdf/v1";
-    readonly title: "CDF Component Definition Format v1";
+    readonly $id: "https://contentful.com/schemas/cdf";
+    readonly title: "CDF Component + Design Token Definition Format";
     readonly type: "object";
     readonly required: readonly ["$schema"];
     readonly properties: {
         readonly $schema: {
             readonly type: "string";
-            readonly const: "https://contentful.com/schemas/cdf/v1";
+            readonly const: "https://contentful.com/schemas/cdf";
         };
     };
     readonly additionalProperties: {
-        readonly $ref: "#/definitions/groupOrComponent";
+        readonly $ref: "#/definitions/groupOrEntry";
     };
     readonly definitions: {
-        readonly groupOrComponent: {
+        readonly groupOrEntry: {
             readonly oneOf: readonly [{
                 readonly $ref: "#/definitions/component";
+            }, {
+                readonly $ref: "#/definitions/token";
             }, {
                 readonly $ref: "#/definitions/group";
             }];
@@ -103,6 +112,21 @@ export declare const cdfV1JsonSchema: {
             };
             readonly additionalProperties: false;
         };
+        readonly token: {
+            readonly type: "object";
+            readonly required: readonly ["$type", "$value"];
+            readonly properties: {
+                readonly $type: {
+                    readonly type: "string";
+                    readonly enum: readonly ["color", "dimension", "fontFamily", "fontWeight", "duration", "cubicBezier", "number", "strokeStyle", "border", "transition", "shadow", "gradient", "typography"];
+                };
+                readonly $value: {};
+                readonly $description: {
+                    readonly type: "string";
+                };
+            };
+            readonly additionalProperties: false;
+        };
         readonly group: {
             readonly type: "object";
             readonly properties: {
@@ -111,7 +135,7 @@ export declare const cdfV1JsonSchema: {
                 };
             };
             readonly additionalProperties: {
-                readonly $ref: "#/definitions/groupOrComponent";
+                readonly $ref: "#/definitions/groupOrEntry";
             };
         };
     };

package/dist/src/cdf/schema.js

@@ -1,18 +1,26 @@
 import { CDF_PROPERTY_TYPES, CDF_PROPERTY_CATEGORIES } from './vocabularies.js';
-export const CDF_V1_SCHEMA_URL = 'https://contentful.com/schemas/cdf/v1';
-export const cdfV1JsonSchema = {
+import { DESIGN_TOKEN_TYPES } from '../dtcg/token-types.js';
+export const CDF_SCHEMA_URL = 'https://contentful.com/schemas/cdf';
+/**
+ * Components and design tokens live in one recursive tree. A leaf's `$type`
+ * decides what it is ('component' vs. a DESIGN_TOKEN_TYPES member), so the
+ * same `group` container can hold either kind side by side. There is no
+ * separate manifest envelope — this document is the single file/wire
+ * payload sent to preview/apply.
+ */
+export const cdfJsonSchema = {
     $schema: 'http://json-schema.org/draft-07/schema#',
-    $id: CDF_V1_SCHEMA_URL,
-    title: 'CDF Component Definition Format v1',
+    $id: CDF_SCHEMA_URL,
+    title: 'CDF Component + Design Token Definition Format',
     type: 'object',
     required: ['$schema'],
     properties: {
-        $schema: { type: 'string', const: CDF_V1_SCHEMA_URL },
+        $schema: { type: 'string', const: CDF_SCHEMA_URL },
     },
-    additionalProperties: { $ref: '#/definitions/groupOrComponent' },
+    additionalProperties: { $ref: '#/definitions/groupOrEntry' },
     definitions: {
-        groupOrComponent: {
-            oneOf: [{ $ref: '#/definitions/component' }, { $ref: '#/definitions/group' }],
+        groupOrEntry: {
+            oneOf: [{ $ref: '#/definitions/component' }, { $ref: '#/definitions/token' }, { $ref: '#/definitions/group' }],
         },
         component: {
             type: 'object',
@@ -55,10 +63,20 @@ export const cdfV1JsonSchema = {
             },
             additionalProperties: false,
         },
+        token: {
+            type: 'object',
+            required: ['$type', '$value'],
+            properties: {
+                $type: { type: 'string', enum: [...DESIGN_TOKEN_TYPES] },
+                $value: {},
+                $description: { type: 'string' },
+            },
+            additionalProperties: false,
+        },
         group: {
             type: 'object',
             properties: { $description: { type: 'string' } },
-            additionalProperties: { $ref: '#/definitions/groupOrComponent' },
+            additionalProperties: { $ref: '#/definitions/groupOrEntry' },
         },
     },
 };

package/dist/src/cdf/types.d.ts

@@ -74,6 +74,28 @@ export interface CDFValidationError {
     expected?: string;
     actual?: string;
 }
+/** A token leaf — same shape as a DTCG token entry, but discovered inside
+ * the CDF tree rather than a standalone DTCG document. */
+export declare const CDFTokenSchema: z.ZodMiniObject<{
+    $type: z.ZodMiniEnum<{
+        number: "number";
+        color: "color";
+        dimension: "dimension";
+        fontFamily: "fontFamily";
+        fontWeight: "fontWeight";
+        duration: "duration";
+        cubicBezier: "cubicBezier";
+        strokeStyle: "strokeStyle";
+        border: "border";
+        transition: "transition";
+        shadow: "shadow";
+        gradient: "gradient";
+        typography: "typography";
+    }>;
+    $value: z.ZodMiniUnknown;
+    $description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+}, z.core.$strict>;
+export type CDFTokenEntry = z.infer<typeof CDFTokenSchema>;
 export interface CDFValidationResult {
     valid: boolean;
     errors: CDFValidationError[];
@@ -81,4 +103,8 @@ export interface CDFValidationResult {
         key: string;
         entry: CDFComponentEntry;
     }>;
+    tokens: Array<{
+        path: string;
+        entry: CDFTokenEntry;
+    }>;
 }

package/dist/src/cdf/types.js

@@ -1,5 +1,6 @@
 import * as z from 'zod/mini';
 import { CDF_PROPERTY_TYPES, CDF_PROPERTY_CATEGORIES } from './vocabularies.js';
+import { DESIGN_TOKEN_TYPES } from '../dtcg/token-types.js';
 export const CDFPropertySchema = z.strictObject({
     $type: z.enum(CDF_PROPERTY_TYPES),
     $category: z.enum(CDF_PROPERTY_CATEGORIES),
@@ -21,3 +22,10 @@ export const CDFComponentSchema = z.strictObject({
     $properties: z.record(z.string(), CDFPropertySchema),
     $slots: z.optional(z.record(z.string(), CDFSlotSchema)),
 });
+/** A token leaf — same shape as a DTCG token entry, but discovered inside
+ * the CDF tree rather than a standalone DTCG document. */
+export const CDFTokenSchema = z.strictObject({
+    $type: z.enum(DESIGN_TOKEN_TYPES),
+    $value: z.unknown(),
+    $description: z.optional(z.string()),
+});

package/dist/src/cdf/validate.d.ts

@@ -1,6 +1,18 @@
-import type { CDFComponentEntry, CDFValidationResult } from './types.js';
-export declare function parseCDFComponents(obj: Record<string, unknown>, prefix?: string): Array<{
-    key: string;
-    entry: CDFComponentEntry;
-}>;
+import type { CDFComponentEntry, CDFTokenEntry, CDFValidationResult } from './types.js';
+/**
+ * Walks the CDF tree once, splitting every leaf into a component or a
+ * token by its `$type` (the two vocabularies — 'component' vs.
+ * DESIGN_TOKEN_TYPES — are disjoint by construction). Groups (plain nested
+ * objects that are neither) recurse.
+ */
+export declare function parseCDFComponents(obj: Record<string, unknown>, prefix?: string): {
+    components: Array<{
+        key: string;
+        entry: CDFComponentEntry;
+    }>;
+    tokens: Array<{
+        path: string;
+        entry: CDFTokenEntry;
+    }>;
+};
 export declare function validateCDF(input: unknown): CDFValidationResult;

package/dist/src/cdf/validate.js

@@ -1,26 +1,43 @@
 import { Ajv } from 'ajv';
-import { cdfV1JsonSchema, CDF_V1_SCHEMA_URL } from './schema.js';
+import { cdfJsonSchema, CDF_SCHEMA_URL } from './schema.js';
+import { DESIGN_TOKEN_TYPES } from '../dtcg/token-types.js';
 const ajv = new Ajv({ allErrors: true });
-const validate = ajv.compile(cdfV1JsonSchema);
+const validate = ajv.compile(cdfJsonSchema);
+const TOKEN_TYPE_SET = new Set(DESIGN_TOKEN_TYPES);
 function isComponentEntry(value) {
+    return typeof value === 'object' && value !== null && value['$type'] === 'component';
+}
+function isTokenEntry(value) {
     return (typeof value === 'object' &&
         value !== null &&
-        '$type' in value &&
-        value['$type'] === 'component');
+        TOKEN_TYPE_SET.has(value['$type']));
 }
+/**
+ * Walks the CDF tree once, splitting every leaf into a component or a
+ * token by its `$type` (the two vocabularies — 'component' vs.
+ * DESIGN_TOKEN_TYPES — are disjoint by construction). Groups (plain nested
+ * objects that are neither) recurse.
+ */
 export function parseCDFComponents(obj, prefix = '') {
-    const results = [];
+    const components = [];
+    const tokens = [];
     for (const [key, value] of Object.entries(obj)) {
         if (key.startsWith('$'))
             continue;
+        const path = prefix ? `${prefix}.${key}` : key;
         if (isComponentEntry(value)) {
-            results.push({ key: prefix ? `${prefix}.${key}` : key, entry: value });
+            components.push({ key: path, entry: value });
+        }
+        else if (isTokenEntry(value)) {
+            tokens.push({ path, entry: value });
         }
         else if (typeof value === 'object' && value !== null) {
-            results.push(...parseCDFComponents(value, prefix ? `${prefix}.${key}` : key));
+            const nested = parseCDFComponents(value, path);
+            components.push(...nested.components);
+            tokens.push(...nested.tokens);
         }
     }
-    return results;
+    return { components, tokens };
 }
 export function validateCDF(input) {
     const valid = validate(input);
@@ -30,23 +47,24 @@ export function validateCDF(input) {
             message: err.message ?? 'Unknown validation error',
             expected: err.params ? JSON.stringify(err.params) : undefined,
         }));
-        return { valid: false, errors, components: [] };
+        return { valid: false, errors, components: [], tokens: [] };
     }
     const file = input;
-    if (file.$schema !== CDF_V1_SCHEMA_URL) {
+    if (file.$schema !== CDF_SCHEMA_URL) {
         return {
             valid: false,
             errors: [
                 {
                     path: '/$schema',
-                    message: `Expected schema "${CDF_V1_SCHEMA_URL}"`,
-                    expected: CDF_V1_SCHEMA_URL,
+                    message: `Expected schema "${CDF_SCHEMA_URL}"`,
+                    expected: CDF_SCHEMA_URL,
                     actual: file.$schema,
                 },
             ],
             components: [],
+            tokens: [],
         };
     }
-    const components = parseCDFComponents(file);
-    return { valid: true, errors: [], components };
+    const { components, tokens } = parseCDFComponents(file);
+    return { valid: true, errors: [], components, tokens };
 }

package/dist/src/index.d.ts

@@ -1,6 +1,4 @@
-export { validateCDF, parseCDFComponents, CDF_V1_SCHEMA_URL, CDF_PROPERTY_TYPES, CDF_PROPERTY_CATEGORIES, CDFComponentSchema, CDFPropertySchema, CDFSlotSchema, type CDFComponentEntry, type CDFPropertyDefinition, type CDFSlotDefinition, type CDFValidationError, } from './cdf/index.js';
+export { validateCDF, parseCDFComponents, CDF_SCHEMA_URL, cdfJsonSchema, CDF_PROPERTY_TYPES, CDF_PROPERTY_CATEGORIES, CDFComponentSchema, CDFPropertySchema, CDFSlotSchema, CDFTokenSchema, buildCDF, buildFilteredCDF, stripUnsupportedSlotFields, validateSlotReferences, type CDFComponentEntry, type CDFPropertyDefinition, type CDFSlotDefinition, type CDFTokenEntry, type CDFValidationError, type CDFValidationResult, type CDFDocument, } from './cdf/index.js';
 export { DESIGN_TOKEN_TYPES, flattenDTCG, validateDTCG, DTCGTokenSchema, type DesignTokenType, type DTCGTokenEntry, type DTCGTokenGroup, type DTCGTokenNode, type DTCGTokenGroupNode, type DTCGValidationError, type DTCGValidationResult, } from './dtcg/index.js';
 export type { BreakingChange, ChangeClassification, DownstreamImpact, PropertySummary, ComponentTypeSummary, DesignTokenSummary, TaxonomySummary, ChangedEntity, EntityDiffGroup, ServerPreviewResponse, } from './sources-api/preview/index.js';
 export type { ApplyOperationStatus, ApplyOperationItemError, ApplyOperationItem, ApplyOperationResponse, ApplyGateError, } from './sources-api/apply/index.js';
-export type { ManifestPayload } from './sources-api/manifest/index.js';
-export { buildManifest, buildFilteredManifest, stripUnsupportedSlotFields } from './sources-api/manifest/index.js';

package/dist/src/index.js

@@ -1,5 +1,5 @@
-// CDF (Component Definition Format) exports
-export { validateCDF, parseCDFComponents, CDF_V1_SCHEMA_URL, CDF_PROPERTY_TYPES, CDF_PROPERTY_CATEGORIES, CDFComponentSchema, CDFPropertySchema, CDFSlotSchema, } from './cdf/index.js';
+// CDF (Component Definition Format) exports — one schema/file for both
+// components and design tokens, no separate manifest envelope.
+export { validateCDF, parseCDFComponents, CDF_SCHEMA_URL, cdfJsonSchema, CDF_PROPERTY_TYPES, CDF_PROPERTY_CATEGORIES, CDFComponentSchema, CDFPropertySchema, CDFSlotSchema, CDFTokenSchema, buildCDF, buildFilteredCDF, stripUnsupportedSlotFields, validateSlotReferences, } from './cdf/index.js';
 // DTCG (W3C Design Token Community Group)
 export { DESIGN_TOKEN_TYPES, flattenDTCG, validateDTCG, DTCGTokenSchema, } from './dtcg/index.js';
-export { buildManifest, buildFilteredManifest, stripUnsupportedSlotFields } from './sources-api/manifest/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-types",
-  "version": "2.34.5-dev-build-d08439d.0",
+  "version": "2.34.5-dev-build-75bf00ac.0",
   "license": "MIT",
   "type": "module",
   "module": "./dist/src/index.js",

package/dist/src/sources-api/manifest/index.d.ts

@@ -1,5 +0,0 @@
-export interface ManifestPayload {
-    componentsManifest?: Record<string, unknown>;
-    tokensManifest?: Record<string, unknown>;
-}
-export { buildManifest, buildFilteredManifest, stripUnsupportedSlotFields } from './utils.js';

package/dist/src/sources-api/manifest/index.js

@@ -1 +0,0 @@
-export { buildManifest, buildFilteredManifest, stripUnsupportedSlotFields } from './utils.js';

package/dist/src/sources-api/manifest/utils.d.ts

@@ -1,11 +0,0 @@
-import type { CDFComponentEntry } from '../../cdf/index.js';
-import type { DTCGTokenEntry } from '../../dtcg/types.js';
-import type { ManifestPayload } from './index.js';
-export declare function stripUnsupportedSlotFields(entry: CDFComponentEntry): CDFComponentEntry;
-export declare function buildManifest(components: Array<{
-    key: string;
-    entry: CDFComponentEntry;
-}>, tokens: DTCGTokenEntry[], opts?: {
-    deleteAllComponents?: boolean;
-}): ManifestPayload;
-export declare function buildFilteredManifest(fullManifest: ManifestPayload, selectedComponentKeys: Set<string>, selectedTokenPaths: Set<string>): ManifestPayload;

package/dist/src/sources-api/manifest/utils.js

@@ -1,64 +0,0 @@
-import { CDF_V1_SCHEMA_URL } from '../../cdf/index.js';
-export function stripUnsupportedSlotFields(entry) {
-    if (!entry.$slots)
-        return entry;
-    const cleaned = {};
-    for (const [name, slot] of Object.entries(entry.$slots)) {
-        const { $required: _required, ...rest } = slot;
-        cleaned[name] = rest;
-    }
-    return { ...entry, $slots: cleaned };
-}
-export function buildManifest(components, tokens, opts = {}) {
-    const manifest = {};
-    // With components, emit them. With none, normally omit the key entirely — but
-    // when `deleteAllComponents` is set, emit an empty-but-present manifest so the
-    // server diffs it as "remove every existing component" (delete-all). An
-    // omitted key is a no-op; a present-empty one is an explicit clear.
-    if (components.length > 0 || opts.deleteAllComponents) {
-        const componentsObj = { $schema: CDF_V1_SCHEMA_URL };
-        for (const { key, entry } of components) {
-            componentsObj[key] = stripUnsupportedSlotFields(entry);
-        }
-        manifest.componentsManifest = componentsObj;
-    }
-    if (tokens.length > 0) {
-        const tokensObj = {};
-        for (const token of tokens) {
-            tokensObj[token.path] = {
-                $type: token.$type,
-                $value: token.$value,
-                ...(token.$description ? { $description: token.$description } : {}),
-            };
-        }
-        manifest.tokensManifest = tokensObj;
-    }
-    return manifest;
-}
-export function buildFilteredManifest(fullManifest, selectedComponentKeys, selectedTokenPaths) {
-    const filtered = {};
-    if (fullManifest.componentsManifest) {
-        const obj = {};
-        if (fullManifest.componentsManifest['$schema']) {
-            obj['$schema'] = fullManifest.componentsManifest['$schema'];
-        }
-        for (const [key, value] of Object.entries(fullManifest.componentsManifest)) {
-            if (key === '$schema')
-                continue;
-            if (selectedComponentKeys.has(key))
-                obj[key] = value;
-        }
-        if (Object.keys(obj).length > 1)
-            filtered.componentsManifest = obj;
-    }
-    if (fullManifest.tokensManifest) {
-        const obj = {};
-        for (const [path, value] of Object.entries(fullManifest.tokensManifest)) {
-            if (selectedTokenPaths.has(path))
-                obj[path] = value;
-        }
-        if (Object.keys(obj).length > 0)
-            filtered.tokensManifest = obj;
-    }
-    return filtered;
-}