@neatico/visual-core 0.14.3 → 0.14.64

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/text.js

@@ -22,7 +22,7 @@ export function wrapCopy(text, width, size, bold, measure, options = {}) {
         }
         const ranges = options.keepWords && typeof Intl.Segmenter === 'function' ? [...new Intl.Segmenter(undefined, { granularity: 'word' }).segment(paragraph)].filter(part => part.isWordLike).map(part => ({ start: part.index, end: part.index + part.segment.length, text: part.segment })) : [];
         // Keep a fitting URL/API token whole even where UAX permits a slash break.
-        for (const match of paragraph.matchAll(/[A-Za-z0-9]+(?:[._/@+\-][A-Za-z0-9]+)+/g))
+        for (const match of paragraph.matchAll(/[A-Za-z0-9]+(?:[.:_/@+\-][A-Za-z0-9]+)+/g))
             ranges.push({ start: match.index, end: match.index + match[0].length, text: match[0] });
         const wrapAt = (available) => {
             const breaker = new LineBreaker(paragraph), tokens = [];
@@ -50,7 +50,17 @@ export function wrapCopy(text, width, size, bold, measure, options = {}) {
                     line = token.trimStart();
                     continue;
                 }
-                const glyphs = typeof Intl.Segmenter === 'function' ? [...new Intl.Segmenter(undefined, { granularity: 'grapheme' }).segment(token)].map(part => part.segment) : Array.from(token);
+                const graphemes = (value) => typeof Intl.Segmenter === 'function' ? [...new Intl.Segmenter(undefined, { granularity: 'grapheme' }).segment(value)].map(part => part.segment) : Array.from(value);
+                // A range may be wider than a column, but a fitting clock must stay intact.
+                // Keep each clock as an atomic fallback unit instead of splitting its minutes.
+                const glyphs = [];
+                let cursor = 0;
+                for (const match of token.matchAll(/\d{1,2}:\d{2}(?::\d{2})?/g)) {
+                    glyphs.push(...graphemes(token.slice(cursor, match.index)));
+                    glyphs.push(...(measured(match[0]) <= available ? [match[0]] : graphemes(match[0])));
+                    cursor = match.index + match[0].length;
+                }
+                glyphs.push(...graphemes(token.slice(cursor)));
                 for (const glyph of glyphs) {
                     if (glyph.trim() && measured(glyph) > available)
                         throw new RangeError('A character exceeds the available width');

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.3",
+  "version": "0.14.64",
   "description": "Framework-independent geometry, measured text wrapping, and extensible scene registries for visual editors.",
   "type": "module",
   "main": "./dist/cjs/index.js",