@adecore/intelligent-ui 0.25.6 → 0.25.7

package/dist/catalog.d.ts

@@ -140,6 +140,9 @@ export declare const UI_CATALOG: {
         }, z.core.$strict>;
         readonly parent: 'Timeline';
         readonly text: 'title';
+        readonly aliases: {
+            readonly time: 'at';
+        };
     };
     readonly Stats: {
         readonly group: 'data';

package/dist/catalog.js

@@ -59,7 +59,8 @@ export const UI_CATALOG = {
             detail: text.optional()
         }),
         parent: 'Timeline',
-        text: 'title'
+        text: 'title',
+        aliases: { time: 'at' }
     },
     Stats: { group: 'data', description: 'A small set of key numbers.', schema: empty, children: ['Stat'] },
     Stat: {

package/dist/compiler.js

@@ -3,6 +3,7 @@ import { isUiComponent, UI_CATALOG, UI_CATALOG_VERSION } from './catalog.js';
 import { uiActionProp, uiActionTarget, uiLocalState } from './actions.js';
 import { unreadableEventTime } from './event-warning.js';
 import { uiNodeFallback, uiPlainText } from './fallback.js';
+import { aliasedProp } from './prop-alias.js';
 import { evaluateUiExpression, sameUiValue } from './expression.js';
 import { parseUiSyntax, uiDiagnostic } from './syntax.js';
 import {} from 'zod';
@@ -193,16 +194,20 @@ export function compileUiBlock(source, options) {
                 }
             }
             const actionProp = uiActionProp(syntax.type);
-            for (const [key, expression] of Object.entries(syntax.props)) {
-                safeKey(key);
-                if (key === actionProp) {
-                    node.expressions[key] = checkedAction(expression);
+            for (const [written, expression] of Object.entries(syntax.props)) {
+                safeKey(written);
+                if (written === actionProp) {
+                    node.expressions[written] = checkedAction(expression);
                     continue;
                 }
+                const key = aliasedProp(entry, written, syntax.props);
                 if (!Object.hasOwn(entry.schema.shape, key)) {
-                    diagnose(new UiFailure('refused_prop', `${syntax.type} does not accept ${key}.`), syntax.start, syntax.end, syntax.id);
+                    diagnose(new UiFailure('refused_prop', `${syntax.type} does not accept ${written}.`), syntax.start, syntax.end, syntax.id);
                     continue;
                 }
+                if (key !== written && syntax.complete) {
+                    diagnose(new UiFailure('renamed_prop', `${syntax.type} takes ${key}, not ${written}; read as ${key}.`), syntax.start, syntax.end, syntax.id);
+                }
                 if (isConstant(expression)) {
                     node.props[key] = evaluateUiExpression(expression, {}, budget);
                 }

package/dist/prop-alias.d.ts

@@ -0,0 +1 @@
+export declare function aliasedProp(entry: object, written: string, props: Readonly<Record<string, unknown>>): string;

package/dist/prop-alias.js

@@ -0,0 +1,6 @@
+/* The prop a written one stands for: its alias in the catalog, unless the real prop is written too, which then wins. */
+export function aliasedProp(entry, written, props) {
+    const aliases = 'aliases' in entry ? entry.aliases : {};
+    const target = Object.hasOwn(aliases, written) ? aliases[written] : undefined;
+    return target === undefined || Object.hasOwn(props, target) ? written : target;
+}

package/dist/syntax.js

@@ -1,6 +1,6 @@
 import { safeKey, UiBudget, UiFailure } from './budget.js';
 import { parseUiExpression } from './expression.js';
-const WARNING_CODES = new Set(['refused_prop', 'too_many_series', 'too_many_children', 'unreadable_time']);
+const WARNING_CODES = new Set(['refused_prop', 'renamed_prop', 'too_many_series', 'too_many_children', 'unreadable_time']);
 export function uiDiagnostic(error, start, end, nodeId) {
     const code = error instanceof UiFailure ? error.code : 'invalid_syntax';
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/intelligent-ui",
-  "version": "0.25.6",
+  "version": "0.25.7",
   "description": "A streaming UI catalog, compiler and bounded expression interpreter without a framework or DOM.",
   "license": "FSL-1.1-MIT",
   "author": "Bas Milius",

package/src/catalog.ts

@@ -65,7 +65,8 @@ export const UI_CATALOG = {
             detail: text.optional()
         }),
         parent: 'Timeline',
-        text: 'title'
+        text: 'title',
+        aliases: { time: 'at' }
     },
     Stats: { group: 'data', description: 'A small set of key numbers.', schema: empty, children: ['Stat'] },
     Stat: {

package/src/compiler.ts

@@ -3,6 +3,7 @@ import { isUiComponent, UI_CATALOG, UI_CATALOG_VERSION } from './catalog.ts';
 import { uiActionProp, uiActionTarget, uiLocalState } from './actions.ts';
 import { unreadableEventTime } from './event-warning.ts';
 import { uiNodeFallback, uiPlainText } from './fallback.ts';
+import { aliasedProp } from './prop-alias.ts';
 import { evaluateUiExpression, sameUiValue, type UiExpression, type UiValue } from './expression.ts';
 import { parseUiSyntax, uiDiagnostic, type UiDiagnostic, type UiSyntaxNode } from './syntax.ts';
 import { type z } from 'zod';
@@ -266,16 +267,25 @@ export function compileUiBlock(source: string, options: UiCompileOptions): UiBlo
                 }
             }
             const actionProp = uiActionProp(syntax.type);
-            for (const [key, expression] of Object.entries(syntax.props)) {
-                safeKey(key);
-                if (key === actionProp) {
-                    node.expressions[key] = checkedAction(expression);
+            for (const [written, expression] of Object.entries(syntax.props)) {
+                safeKey(written);
+                if (written === actionProp) {
+                    node.expressions[written] = checkedAction(expression);
                     continue;
                 }
+                const key = aliasedProp(entry, written, syntax.props);
                 if (!Object.hasOwn(entry.schema.shape, key)) {
-                    diagnose(new UiFailure('refused_prop', `${syntax.type} does not accept ${key}.`), syntax.start, syntax.end, syntax.id);
+                    diagnose(new UiFailure('refused_prop', `${syntax.type} does not accept ${written}.`), syntax.start, syntax.end, syntax.id);
                     continue;
                 }
+                if (key !== written && syntax.complete) {
+                    diagnose(
+                        new UiFailure('renamed_prop', `${syntax.type} takes ${key}, not ${written}; read as ${key}.`),
+                        syntax.start,
+                        syntax.end,
+                        syntax.id
+                    );
+                }
                 if (isConstant(expression)) {
                     node.props[key] = evaluateUiExpression(expression, {}, budget);
                 } else {

package/src/prop-alias.ts

@@ -0,0 +1,6 @@
+/* The prop a written one stands for: its alias in the catalog, unless the real prop is written too, which then wins. */
+export function aliasedProp(entry: object, written: string, props: Readonly<Record<string, unknown>>): string {
+    const aliases = 'aliases' in entry ? (entry.aliases as Readonly<Record<string, string>>) : {};
+    const target = Object.hasOwn(aliases, written) ? aliases[written] : undefined;
+    return target === undefined || Object.hasOwn(props, target) ? written : target;
+}

package/src/syntax.ts

@@ -31,7 +31,7 @@ export interface UiSyntax {
     diagnostics: UiDiagnostic[];
 }
 
-const WARNING_CODES = new Set(['refused_prop', 'too_many_series', 'too_many_children', 'unreadable_time']);
+const WARNING_CODES = new Set(['refused_prop', 'renamed_prop', 'too_many_series', 'too_many_children', 'unreadable_time']);
 
 export function uiDiagnostic(error: unknown, start: number, end: number, nodeId?: string): UiDiagnostic {
     const code = error instanceof UiFailure ? error.code : 'invalid_syntax';