@neatico/visual-core 0.14.26 → 0.14.65

package/dist/styleManifest.d.ts

@@ -0,0 +1,20 @@
+import { type DesignTheme } from "./designSystem.js";
+/** Persist the resolved tokens, not just a mutable theme name. */
+export interface StyleManifest {
+    version: 1;
+    themeId: string;
+    themeVersion: 1;
+    theme: DesignTheme;
+    fonts: {
+        heading: string;
+        body: string;
+        code: string;
+    };
+    imagery: {
+        medium: "native" | "photography" | "illustration" | "3d";
+        referenceAssetIds: string[];
+        direction: string;
+    };
+}
+export declare function createStyleManifest(themeId: string, copy?: string, imagery?: Partial<StyleManifest["imagery"]>): StyleManifest;
+export declare function validateStyleManifest(value: unknown): StyleManifest;

package/dist/styleManifest.js

@@ -0,0 +1,103 @@
+import { DESIGN_THEMES, designTheme, } from "./designSystem.js";
+import { languageFont } from "./fontCatalog.js";
+export function createStyleManifest(themeId, copy = "", imagery) {
+    const theme = designTheme(themeId);
+    if (!DESIGN_THEMES.some((candidate) => candidate.id === themeId) &&
+        !["paper", "midnight", "ocean", "plum"].includes(themeId))
+        throw new Error("STYLE_UNKNOWN_THEME");
+    const manifest = {
+        version: 1,
+        themeId: theme.id,
+        themeVersion: 1,
+        theme: {
+            ...theme,
+            palette: { ...theme.palette },
+            typography: { ...theme.typography },
+            geometry: { ...theme.geometry },
+        },
+        fonts: {
+            heading: languageFont(copy, theme.typography.heading),
+            body: languageFont(copy, theme.typography.body),
+            code: theme.typography.code === "monospace"
+                ? "JetBrains Mono"
+                : theme.typography.code,
+        },
+        imagery: {
+            medium: "native",
+            referenceAssetIds: [],
+            direction: "",
+            ...imagery,
+        },
+    };
+    return validateStyleManifest(manifest);
+}
+export function validateStyleManifest(value) {
+    const manifest = value;
+    const fail = () => {
+        throw new Error("STYLE_INVALID_MANIFEST");
+    };
+    if (!manifest ||
+        manifest.version !== 1 ||
+        manifest.themeVersion !== 1 ||
+        typeof manifest.themeId !== "string" ||
+        !manifest.theme ||
+        manifest.theme.id !== manifest.themeId ||
+        !DESIGN_THEMES.some((theme) => theme.id === manifest.themeId))
+        return fail();
+    const { palette, typography, geometry } = manifest.theme;
+    if (!palette ||
+        ["background", "surface", "ink", "muted", "accent", "line"].some((key) => !/^#[\da-f]{6}$/i.test(palette[key] || "")))
+        return fail();
+    if (!typography ||
+        ["heading", "body", "code"].some((key) => typeof typography[key] !==
+            "string") ||
+        !Number.isInteger(typography.headingWeight) ||
+        typography.headingWeight < 100 ||
+        typography.headingWeight > 900)
+        return fail();
+    if (!geometry ||
+        !Number.isFinite(geometry.radius) ||
+        geometry.radius < 0 ||
+        geometry.radius > 100 ||
+        !Number.isFinite(geometry.spacing) ||
+        geometry.spacing <= 0 ||
+        geometry.spacing > 4 ||
+        !["none", "hairline", "accent"].includes(geometry.rule))
+        return fail();
+    if (!manifest.fonts ||
+        Object.keys(manifest.fonts).length !== 3 ||
+        ["heading", "body", "code"].some((key) => {
+            const font = manifest.fonts[key];
+            return typeof font !== "string" || !font.trim() || font.length > 100;
+        }))
+        return fail();
+    if (!manifest.imagery ||
+        !["native", "photography", "illustration", "3d"].includes(manifest.imagery.medium) ||
+        typeof manifest.imagery.direction !== "string" ||
+        manifest.imagery.direction.length > 2000 ||
+        !Array.isArray(manifest.imagery.referenceAssetIds) ||
+        manifest.imagery.referenceAssetIds.length > 16 ||
+        manifest.imagery.referenceAssetIds.some((id) => typeof id !== "string" || !id || id.length > 160))
+        return fail();
+    return {
+        version: 1,
+        themeId: manifest.themeId,
+        themeVersion: 1,
+        theme: {
+            id: manifest.themeId,
+            palette: { ...palette },
+            typography: { ...typography },
+            geometry: { ...geometry },
+        },
+        fonts: {
+            heading: manifest.fonts.heading,
+            body: manifest.fonts.body,
+            code: manifest.fonts.code,
+        },
+        imagery: {
+            medium: manifest.imagery.medium,
+            direction: manifest.imagery.direction,
+            referenceAssetIds: [...manifest.imagery.referenceAssetIds],
+        },
+    };
+}

package/dist/textPresentation.d.ts

@@ -0,0 +1,29 @@
+/** Closed presentation intent. Content stays in its original field, never in CSS. */
+export interface TextPresentationLine {
+    text: string;
+    font: 'display' | 'body' | 'mono';
+    scale: number;
+    tone: 'ink' | 'accent' | 'secondary';
+    decoration: 'none' | 'marker' | 'underline';
+    italic: boolean;
+}
+export interface TextPresentation {
+    path: string;
+    fit: 'natural' | 'equal-width';
+    lines: TextPresentationLine[];
+}
+export declare function textPresentationSchema(): {
+    type: string;
+    minItems: number;
+    maxItems: number;
+    default: never[];
+    description: string;
+    items: {
+        type: string;
+        additionalProperties: boolean;
+        properties: Record<string, unknown>;
+        required: string[];
+    };
+};
+/** Validate exact source reconstruction; script-aware boundaries permit CJK breaks. */
+export declare function validateTextPresentations(value: unknown, content: Record<string, unknown>): TextPresentation[];

package/dist/textPresentation.js

@@ -0,0 +1,64 @@
+const object = (properties) => ({
+    type: 'object', additionalProperties: false, properties, required: Object.keys(properties),
+});
+export function textPresentationSchema() {
+    return {
+        type: 'array', minItems: 0, maxItems: 8, default: [],
+        description: 'Optional typography for visible text fields, including title, body, item descriptions and quotations. Use a few deliberate contrasts within the shared suite. Every line must preserve the original field text and word boundaries. Empty uses the authored typography. Never style code, evidence, IDs or asset metadata.',
+        items: object({
+            path: { type: 'string', minLength: 1, maxLength: 120, description: 'Exact dot path of the visible text field, such as body, items.0.description or blocks.0.text.' },
+            fit: { type: 'string', enum: ['natural', 'equal-width'], description: 'Equal-width adjusts each line independently within readable size limits; it never stretches glyphs.' },
+            lines: { type: 'array', minItems: 1, maxItems: 8, items: object({
+                    text: { type: 'string', minLength: 1, maxLength: 220, description: 'One complete phrase copied exactly from the target field. All lines together must preserve that entire field.' },
+                    font: { type: 'string', enum: ['display', 'body', 'mono'] },
+                    scale: { type: 'number', minimum: 0.8, maximum: 1.35 },
+                    tone: { type: 'string', enum: ['ink', 'accent', 'secondary'] },
+                    decoration: { type: 'string', enum: ['none', 'marker', 'underline'] },
+                    italic: { type: 'boolean' },
+                }) },
+        }),
+    };
+}
+const normalize = (text) => text.normalize('NFC').replace(/\s+/gu, ' ').trim();
+const word = (character) => /[\p{Script=Latin}\p{Script=Cyrillic}\p{Script=Greek}\p{Number}]/u.test(character);
+/** Validate exact source reconstruction; script-aware boundaries permit CJK breaks. */
+export function validateTextPresentations(value, content) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.length > 8)
+        throw new Error('TEXT_PRESENTATION_INVALID');
+    const paths = new Set();
+    for (const entry of value) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            throw new Error('TEXT_PRESENTATION_INVALID');
+        if (Object.keys(entry).some(key => !['path', 'fit', 'lines'].includes(key)))
+            throw new Error('TEXT_PRESENTATION_INVALID');
+        if (typeof entry.path !== 'string' || !/^(?:title|body|eyebrow|cta|value|attribution|(?:items|blocks)\.\d+\.(?:(?:entries|rows|columns)\.\d+\.)?(?:title|heading|text|description|name|value|attribution|points\.\d+))$/.test(entry.path) || paths.has(entry.path))
+            throw new Error('TEXT_PRESENTATION_PATH');
+        paths.add(entry.path);
+        const copy = entry.path.split('.').reduce((node, key) => node?.[key], content);
+        if (typeof copy !== 'string' || !copy.trim())
+            throw new Error('TEXT_PRESENTATION_PATH');
+        if (!['natural', 'equal-width'].includes(entry.fit) || !Array.isArray(entry.lines) || entry.lines.length < 1 || entry.lines.length > 8)
+            throw new Error('TEXT_PRESENTATION_INVALID');
+        const source = normalize(copy);
+        let cursor = 0;
+        for (const line of entry.lines) {
+            if (!line || typeof line !== 'object' || Array.isArray(line) || Object.keys(line).some(key => !['text', 'font', 'scale', 'tone', 'decoration', 'italic'].includes(key)))
+                throw new Error('TEXT_PRESENTATION_INVALID');
+            if (typeof line.text !== 'string' || !normalize(line.text) || Array.from(line.text).length > 220 || !['display', 'body', 'mono'].includes(line.font) || !Number.isFinite(line.scale) || line.scale < 0.8 || line.scale > 1.35 || !['ink', 'accent', 'secondary'].includes(line.tone) || !['none', 'marker', 'underline'].includes(line.decoration) || typeof line.italic !== 'boolean')
+                throw new Error('TEXT_PRESENTATION_INVALID');
+            const phrase = normalize(line.text);
+            if (source[cursor] === ' ')
+                cursor++;
+            if (!source.startsWith(phrase, cursor))
+                throw new Error('TEXT_PRESENTATION_CONTENT');
+            if (cursor && source[cursor - 1] !== ' ' && word(source[cursor - 1]) && word(phrase[0]))
+                throw new Error('TEXT_PRESENTATION_WORD_BOUNDARY');
+            cursor += phrase.length;
+        }
+        if (cursor !== source.length)
+            throw new Error('TEXT_PRESENTATION_CONTENT');
+    }
+    return value;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neatico/visual-core",
-  "version": "0.14.26",
+  "version": "0.14.65",
   "description": "Framework-independent geometry, measured text wrapping, and extensible scene registries for visual editors.",
   "type": "module",
   "main": "./dist/cjs/index.js",