@adecore/intelligent-ui 0.25.1 → 0.25.2

package/dist/catalog.d.ts

@@ -124,7 +124,7 @@ export declare const UI_CATALOG: {
     };
     readonly Event: {
         readonly group: 'status';
-        readonly description: 'One event at a time or date; children are the title.';
+        readonly description: 'One event at a time or date; children are the title. at is HH:MM[:SS], YYYY-MM-DD, or YYYY-MM-DDTHH:MM[:SS] with an optional Z or ±HH:MM.';
         readonly schema: z.ZodObject<{
             at: z.ZodString;
             tone: z.ZodOptional<z.ZodEnum<{

package/dist/catalog.js

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import { parseUiEventTime } from './event-time.js';
 import { uiPropList } from './prop-list.js';
 export const UI_CATALOG_VERSION = 1;
 export const UiToneSchema = z.enum(['neutral', 'info', 'success', 'warning', 'danger']);
@@ -51,9 +50,9 @@ export const UI_CATALOG = {
     Timeline: { group: 'status', description: 'Events in time order.', schema: empty, children: ['Event'], count: { min: 1 } },
     Event: {
         group: 'status',
-        description: 'One event at a time or date; children are the title.',
+        description: 'One event at a time or date; children are the title. at is HH:MM[:SS], YYYY-MM-DD, or YYYY-MM-DDTHH:MM[:SS] with an optional Z or ±HH:MM.',
         schema: z.strictObject({
-            at: text.refine((value) => parseUiEventTime(value) !== null, 'At must be HH:MM, YYYY-MM-DD or an ISO date-time.'),
+            at: text,
             tone,
             detail: text.optional()
         }),

package/dist/compiler.js

@@ -1,6 +1,7 @@
 import { safeKey, UI_LIMITS, UiBudget, UiFailure } from './budget.js';
 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 { evaluateUiExpression, sameUiValue } from './expression.js';
 import { parseUiSyntax, uiDiagnostic } from './syntax.js';
@@ -241,6 +242,10 @@ export function compileUiBlock(source, options) {
                     throw new UiFailure('invalid_props', parsed.error.issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`).join('; '));
                 }
             }
+            const unreadable = !unresolved && syntax.complete && syntax.type === 'Event' ? unreadableEventTime(evaluated.at) : null;
+            if (unreadable !== null) {
+                diagnose(unreadable, syntax.start, syntax.end, syntax.id);
+            }
             // The catalog promises six series, one per chart color; more still reach the values a person can open.
             if (!unresolved && syntax.complete && syntax.type === 'Chart' && chartSeries(evaluated.data) > CHART_SERIES) {
                 diagnose(new UiFailure('too_many_series', `Chart draws up to ${CHART_SERIES} numeric series; the rest are only in its values.`), syntax.start, syntax.end, syntax.id);

package/dist/event-time.d.ts

@@ -2,5 +2,6 @@ export interface UiEventTime {
     kind: 'time' | 'date' | 'datetime';
     date: Date;
     written: boolean;
+    seconds: boolean;
 }
 export declare function parseUiEventTime(at: string): UiEventTime | null;

package/dist/event-time.js

@@ -1,4 +1,4 @@
-const EVENT_TIME = /^(?:(\d{2}):(\d{2})|(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.\d{1,9})?)?(Z|[+-]\d{2}:\d{2})?)?)$/;
+const EVENT_TIME = /^(?:(\d{2}):(\d{2})(?::(\d{2})(?:\.\d{1,9})?)?|(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.\d{1,9})?)?(Z|[+-]\d{2}:\d{2})?)?)$/;
 function validClock(hour, minute, second = 0) {
     return hour <= 23 && minute <= 59 && second <= 59;
 }
@@ -11,17 +11,23 @@ function zoneOffset(zone) {
     const offset = (zone[0] === '-' ? -1 : 1) * (hours * 60 + minutes);
     return minutes > 59 || offset < -12 * 60 || offset > 14 * 60 ? null : offset;
 }
-/* The moment an Event's `at` names, or null when it is no `HH:MM`, `YYYY-MM-DD` or ISO date-time with an optional offset. */
+/* The moment an Event's `at` names, or null when it is no `HH:MM[:SS]`, `YYYY-MM-DD` or ISO date-time with an optional offset. */
 export function parseUiEventTime(at) {
     const match = EVENT_TIME.exec(at);
     if (match === null) {
         return null;
     }
-    const [, clockHour, clockMinute, year, month, day, hour, minute, second, zone] = match.map((part) => part);
+    const [, clockHour, clockMinute, clockSecond, year, month, day, hour, minute, second, zone] = match.map((part) => part);
     if (clockHour !== undefined) {
         // The day is not shown for a time, so any day will do.
-        return validClock(Number(clockHour), Number(clockMinute))
-            ? { kind: 'time', date: new Date(Date.UTC(2000, 0, 1, Number(clockHour), Number(clockMinute))), written: true }
+        const clockSeconds = Number(clockSecond ?? 0);
+        return validClock(Number(clockHour), Number(clockMinute), clockSeconds)
+            ? {
+                kind: 'time',
+                date: new Date(Date.UTC(2000, 0, 1, Number(clockHour), Number(clockMinute), clockSeconds)),
+                written: true,
+                seconds: clockSecond !== undefined
+            }
             : null;
     }
     const [y, m, d] = [Number(year), Number(month), Number(day)];
@@ -30,15 +36,15 @@ export function parseUiEventTime(at) {
         return null;
     }
     if (hour === undefined) {
-        return { kind: 'date', date: calendar, written: true };
+        return { kind: 'date', date: calendar, written: true, seconds: false };
     }
     const [h, min, sec] = [Number(hour), Number(minute), Number(second ?? 0)];
     if (!validClock(h, min, sec)) {
         return null;
     }
     if (zone === undefined) {
-        return { kind: 'datetime', date: new Date(Date.UTC(y, m - 1, d, h, min, sec)), written: true };
+        return { kind: 'datetime', date: new Date(Date.UTC(y, m - 1, d, h, min, sec)), written: true, seconds: false };
     }
     const offset = zoneOffset(zone);
-    return offset === null ? null : { kind: 'datetime', date: new Date(Date.UTC(y, m - 1, d, h, min, sec) - offset * 60000), written: false };
+    return offset === null ? null : { kind: 'datetime', date: new Date(Date.UTC(y, m - 1, d, h, min, sec) - offset * 60000), written: false, seconds: false };
 }

package/dist/event-warning.d.ts

@@ -0,0 +1,2 @@
+import { UiFailure } from './budget.ts';
+export declare function unreadableEventTime(at: unknown): UiFailure | null;

package/dist/event-warning.js

@@ -0,0 +1,10 @@
+import { UiFailure } from './budget.js';
+import { parseUiEventTime } from './event-time.js';
+/* The warning for an Event whose `at` cannot be read, or null when it can. The Event still draws, with `at` as written. */
+export function unreadableEventTime(at) {
+    if (typeof at !== 'string' || parseUiEventTime(at) !== null) {
+        return null;
+    }
+    const shown = at.length > 40 ? `${at.slice(0, 40)}...` : at;
+    return new UiFailure('unreadable_time', `Event at="${shown}" is not HH:MM[:SS], YYYY-MM-DD or YYYY-MM-DDTHH:MM[:SS] with an optional Z or ±HH:MM, so it is shown as written.`);
+}

package/dist/protocol.d.ts

@@ -7,6 +7,7 @@ export declare const UiDiagnosticSchema: z.ZodObject<{
     start: z.ZodNumber;
     end: z.ZodNumber;
     nodeId: z.ZodOptional<z.ZodString>;
+    severity: z.ZodOptional<z.ZodLiteral<"warning">>;
 }, z.core.$strip>;
 export declare const UiBlockSchema: z.ZodType<UiBlock>;
 export declare const UiBlocksSchema: z.ZodArray<z.ZodType<UiBlock, unknown, z.core.$ZodTypeInternals<UiBlock, unknown>>>;

package/dist/protocol.js

@@ -20,7 +20,8 @@ export const UiDiagnosticSchema = z.object({
     message: z.string(),
     start: position,
     end: position,
-    nodeId: z.string().optional()
+    nodeId: z.string().optional(),
+    severity: z.literal('warning').optional()
 });
 export const UiBlockSchema = z.object({
     id: z.string(),

package/dist/runtime.js

@@ -4,6 +4,7 @@ import { isUiComponent, UI_CATALOG, UI_CATALOG_VERSION } from './catalog.js';
 import {} from './compiler.js';
 import { uiActionProp, uiActionTarget, uiLocalState } from './actions.js';
 import { uiCompiledNodes, uiVisibleInputs } from './inputs.js';
+import { unreadableEventTime } from './event-warning.js';
 import { uiDiagnostic } from './syntax.js';
 export class UiState {
     id = '';
@@ -150,6 +151,14 @@ export function evaluateUiBlock(block, state = new UiState(block), limits = {})
                 throw new UiFailure('invalid_props', parsed.error.issues.map((issue) => issue.message).join('; '));
             }
             view.props = parsed.data;
+            const unreadable = node.complete && node.type === 'Event' ? unreadableEventTime(props.at) : null;
+            // The compiler already warned about a time it could read from the source; this one waited on an Each or a query.
+            if (unreadable !== null &&
+                ![...block.diagnostics, ...result.diagnostics].some((item) => item.code === 'unreadable_time' && item.nodeId === node.id)) {
+                if (result.diagnostics.length < budget.limits.diagnostics) {
+                    result.diagnostics.push(uiDiagnostic(unreadable, node.start, node.end, node.id));
+                }
+            }
             if (node.type === 'Show') {
                 return props.when ? children(node.children, variables, depth + 1, suffix) : [];
             }

package/dist/syntax.d.ts

@@ -6,6 +6,7 @@ export interface UiDiagnostic {
     start: number;
     end: number;
     nodeId?: string;
+    severity?: 'warning';
 }
 export interface UiSyntaxNode {
     id: string;

package/dist/syntax.js

@@ -1,8 +1,11 @@
 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']);
 export function uiDiagnostic(error, start, end, nodeId) {
+    const code = error instanceof UiFailure ? error.code : 'invalid_syntax';
     return {
-        code: error instanceof UiFailure ? error.code : 'invalid_syntax',
+        code,
+        ...(WARNING_CODES.has(code) ? { severity: 'warning' } : {}),
         message: error instanceof Error ? error.message : 'Invalid UI syntax.',
         start,
         end,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/intelligent-ui",
-  "version": "0.25.1",
+  "version": "0.25.2",
   "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

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import { parseUiEventTime } from './event-time.ts';
 import { uiPropList } from './prop-list.ts';
 
 export const UI_CATALOG_VERSION = 1;
@@ -56,9 +55,10 @@ export const UI_CATALOG = {
     Timeline: { group: 'status', description: 'Events in time order.', schema: empty, children: ['Event'], count: { min: 1 } },
     Event: {
         group: 'status',
-        description: 'One event at a time or date; children are the title.',
+        description:
+            'One event at a time or date; children are the title. at is HH:MM[:SS], YYYY-MM-DD, or YYYY-MM-DDTHH:MM[:SS] with an optional Z or ±HH:MM.',
         schema: z.strictObject({
-            at: text.refine((value) => parseUiEventTime(value) !== null, 'At must be HH:MM, YYYY-MM-DD or an ISO date-time.'),
+            at: text,
             tone,
             detail: text.optional()
         }),

package/src/compiler.ts

@@ -1,6 +1,7 @@
 import { safeKey, UI_LIMITS, UiBudget, UiFailure, type UiLimits } from './budget.ts';
 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 { evaluateUiExpression, sameUiValue, type UiExpression, type UiValue } from './expression.ts';
 import { parseUiSyntax, uiDiagnostic, type UiDiagnostic, type UiSyntaxNode } from './syntax.ts';
@@ -312,6 +313,10 @@ export function compileUiBlock(source: string, options: UiCompileOptions): UiBlo
                     throw new UiFailure('invalid_props', parsed.error.issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`).join('; '));
                 }
             }
+            const unreadable = !unresolved && syntax.complete && syntax.type === 'Event' ? unreadableEventTime(evaluated.at) : null;
+            if (unreadable !== null) {
+                diagnose(unreadable, syntax.start, syntax.end, syntax.id);
+            }
             // The catalog promises six series, one per chart color; more still reach the values a person can open.
             if (!unresolved && syntax.complete && syntax.type === 'Chart' && chartSeries(evaluated.data) > CHART_SERIES) {
                 diagnose(

package/src/event-time.ts

@@ -1,10 +1,13 @@
-const EVENT_TIME = /^(?:(\d{2}):(\d{2})|(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.\d{1,9})?)?(Z|[+-]\d{2}:\d{2})?)?)$/;
+const EVENT_TIME =
+    /^(?:(\d{2}):(\d{2})(?::(\d{2})(?:\.\d{1,9})?)?|(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.\d{1,9})?)?(Z|[+-]\d{2}:\d{2})?)?)$/;
 
 export interface UiEventTime {
     kind: 'time' | 'date' | 'datetime';
     date: Date;
     // True when the text gave no offset: `date` then holds the parts as written in UTC, to be written in UTC, so no zone or clock change moves them. False is a real instant, to be written in the reader's zone.
     written: boolean;
+    // True for a lone time that wrote seconds (`14:05:30`), which then shows them. A date-time shows its minutes only.
+    seconds: boolean;
 }
 
 function validClock(hour: number, minute: number, second = 0): boolean {
@@ -21,17 +24,23 @@ function zoneOffset(zone: string): number | null {
     return minutes > 59 || offset < -12 * 60 || offset > 14 * 60 ? null : offset;
 }
 
-/* The moment an Event's `at` names, or null when it is no `HH:MM`, `YYYY-MM-DD` or ISO date-time with an optional offset. */
+/* The moment an Event's `at` names, or null when it is no `HH:MM[:SS]`, `YYYY-MM-DD` or ISO date-time with an optional offset. */
 export function parseUiEventTime(at: string): UiEventTime | null {
     const match = EVENT_TIME.exec(at);
     if (match === null) {
         return null;
     }
-    const [, clockHour, clockMinute, year, month, day, hour, minute, second, zone] = match.map((part) => part as string | undefined);
+    const [, clockHour, clockMinute, clockSecond, year, month, day, hour, minute, second, zone] = match.map((part) => part as string | undefined);
     if (clockHour !== undefined) {
         // The day is not shown for a time, so any day will do.
-        return validClock(Number(clockHour), Number(clockMinute))
-            ? { kind: 'time', date: new Date(Date.UTC(2000, 0, 1, Number(clockHour), Number(clockMinute))), written: true }
+        const clockSeconds = Number(clockSecond ?? 0);
+        return validClock(Number(clockHour), Number(clockMinute), clockSeconds)
+            ? {
+                  kind: 'time',
+                  date: new Date(Date.UTC(2000, 0, 1, Number(clockHour), Number(clockMinute), clockSeconds)),
+                  written: true,
+                  seconds: clockSecond !== undefined
+              }
             : null;
     }
     const [y, m, d] = [Number(year), Number(month), Number(day)];
@@ -40,15 +49,15 @@ export function parseUiEventTime(at: string): UiEventTime | null {
         return null;
     }
     if (hour === undefined) {
-        return { kind: 'date', date: calendar, written: true };
+        return { kind: 'date', date: calendar, written: true, seconds: false };
     }
     const [h, min, sec] = [Number(hour), Number(minute), Number(second ?? 0)];
     if (!validClock(h, min, sec)) {
         return null;
     }
     if (zone === undefined) {
-        return { kind: 'datetime', date: new Date(Date.UTC(y, m - 1, d, h, min, sec)), written: true };
+        return { kind: 'datetime', date: new Date(Date.UTC(y, m - 1, d, h, min, sec)), written: true, seconds: false };
     }
     const offset = zoneOffset(zone);
-    return offset === null ? null : { kind: 'datetime', date: new Date(Date.UTC(y, m - 1, d, h, min, sec) - offset * 60000), written: false };
+    return offset === null ? null : { kind: 'datetime', date: new Date(Date.UTC(y, m - 1, d, h, min, sec) - offset * 60000), written: false, seconds: false };
 }

package/src/event-warning.ts

@@ -0,0 +1,14 @@
+import { UiFailure } from './budget.ts';
+import { parseUiEventTime } from './event-time.ts';
+
+/* The warning for an Event whose `at` cannot be read, or null when it can. The Event still draws, with `at` as written. */
+export function unreadableEventTime(at: unknown): UiFailure | null {
+    if (typeof at !== 'string' || parseUiEventTime(at) !== null) {
+        return null;
+    }
+    const shown = at.length > 40 ? `${at.slice(0, 40)}...` : at;
+    return new UiFailure(
+        'unreadable_time',
+        `Event at="${shown}" is not HH:MM[:SS], YYYY-MM-DD or YYYY-MM-DDTHH:MM[:SS] with an optional Z or ±HH:MM, so it is shown as written.`
+    );
+}

package/src/protocol.ts

@@ -26,7 +26,8 @@ export const UiDiagnosticSchema = z.object({
     message: z.string(),
     start: position,
     end: position,
-    nodeId: z.string().optional()
+    nodeId: z.string().optional(),
+    severity: z.literal('warning').optional()
 });
 
 export const UiBlockSchema: z.ZodType<UiBlock> = z.object({

package/src/runtime.ts

@@ -4,6 +4,7 @@ import { isUiComponent, UI_CATALOG, UI_CATALOG_VERSION } from './catalog.ts';
 import { type UiBlock, type UiNode } from './compiler.ts';
 import { uiActionProp, uiActionTarget, uiLocalState } from './actions.ts';
 import { uiCompiledNodes, uiVisibleInputs } from './inputs.ts';
+import { unreadableEventTime } from './event-warning.ts';
 import { uiDiagnostic, type UiDiagnostic } from './syntax.ts';
 
 export interface UiBinding<Value> {
@@ -185,6 +186,16 @@ export function evaluateUiBlock(block: UiBlock, state = new UiState(block), limi
                 throw new UiFailure('invalid_props', parsed.error.issues.map((issue) => issue.message).join('; '));
             }
             view.props = parsed.data;
+            const unreadable = node.complete && node.type === 'Event' ? unreadableEventTime(props.at) : null;
+            // The compiler already warned about a time it could read from the source; this one waited on an Each or a query.
+            if (
+                unreadable !== null &&
+                ![...block.diagnostics, ...result.diagnostics].some((item) => item.code === 'unreadable_time' && item.nodeId === node.id)
+            ) {
+                if (result.diagnostics.length < budget.limits.diagnostics) {
+                    result.diagnostics.push(uiDiagnostic(unreadable, node.start, node.end, node.id));
+                }
+            }
             if (node.type === 'Show') {
                 return props.when ? children(node.children, variables, depth + 1, suffix) : [];
             }

package/src/syntax.ts

@@ -7,6 +7,8 @@ export interface UiDiagnostic {
     start: number;
     end: number;
     nodeId?: string;
+    // Only a warning says so: the part it names still drew. Absent means an error, a part that could not be drawn.
+    severity?: 'warning';
 }
 
 export interface UiSyntaxNode {
@@ -29,9 +31,13 @@ export interface UiSyntax {
     diagnostics: UiDiagnostic[];
 }
 
+const WARNING_CODES = new Set(['refused_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';
     return {
-        code: error instanceof UiFailure ? error.code : 'invalid_syntax',
+        code,
+        ...(WARNING_CODES.has(code) ? { severity: 'warning' as const } : {}),
         message: error instanceof Error ? error.message : 'Invalid UI syntax.',
         start,
         end,