@golemui/gui-mcp 1.0.2 → 1.1.0

package/json.js

@@ -1,4 +1,4 @@
-import { G, J, a, b, c, g, d, e, f, v } from "./get-concept-Py3iLVmb.js";
+import { G, J, a, b, c, g, d, e, f, v } from "./get-concept-e_HDPrW1.js";
 export {
   G as GET_CONCEPT_TOOL,
   J as JSON_GENERATE_FROM_OPENAPI_TOOL,

package/lib.js

@@ -1,5 +1,5 @@
-import { G, J, a, b, c, g, d, e, f, v } from "./get-concept-Py3iLVmb.js";
-import { D, a as a2, b as b2, c as c2, d as d2, e as e2, g as g2, l, f as f2, t } from "./list-dx-factories-C-Z5Sc5E.js";
+import { G, J, a, b, c, g, d, e, f, v } from "./get-concept-e_HDPrW1.js";
+import { D, a as a2, b as b2, c as c2, d as d2, e as e2, g as g2, l, f as f2, t } from "./list-dx-factories-BlB_usDm.js";
 export {
   D as DX_CHECK_CODE_TOOL,
   a2 as DX_GET_SPEC_TOOL,

package/{list-dx-factories-C-Z5Sc5E.js → list-dx-factories-BlB_usDm.js}

@@ -1,4 +1,4 @@
-import { h as checkReactiveExpression } from "./get-concept-Py3iLVmb.js";
+import { h as checkReactiveExpression } from "./get-concept-e_HDPrW1.js";
 import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
 import { resolve, join, dirname } from "node:path";
@@ -23,7 +23,7 @@ function lintDxSnippet(ts, sourceText, lineOffset) {
     while (ts.isPropertyAccessExpression(e)) e = e.expression;
     return ts.isIdentifier(e) && e.text === "gui";
   };
-  const visit = (node) => {
+  const visit = (node, inTemplate) => {
     if (ts.isObjectLiteralExpression(node)) {
       const spreadsGui = node.properties.some(
         (p) => ts.isSpreadAssignment(p) && isGuiCall(p.expression)
@@ -46,13 +46,17 @@ function lintDxSnippet(ts, sourceText, lineOffset) {
     }
     if (ts.isPropertyAssignment(node) && nameOf(node.name) === "when" && ts.isStringLiteralLike(node.initializer)) {
       const { line, column } = posOf(node.initializer);
-      for (const f of checkReactiveExpression(node.initializer.text, `when@${line}:${column}`)) {
+      const findings = checkReactiveExpression(node.initializer.text, `when@${line}:${column}`, {
+        inRepeaterTemplate: inTemplate
+      });
+      for (const f of findings) {
         expressionWarnings.push(f);
       }
     }
-    ts.forEachChild(node, visit);
+    const childInTemplate = inTemplate || ts.isPropertyAssignment(node) && nameOf(node.name) === "template";
+    ts.forEachChild(node, (child) => visit(child, childInTemplate));
   };
-  visit(sf);
+  visit(sf, false);
   return { diagnostics, expressionWarnings };
 }
 let cachedRequire;
@@ -365,6 +369,33 @@ const INPUTS = [
       "`minDate` / `maxDate` (ISO `YYYY-MM-DD` strings) constrain the accepted range — see `datePicker`."
     ]
   },
+  {
+    factory: "timeInput",
+    namespace: "inputs",
+    call: "gui.inputs.timeInput(path, { label, hourFormat?, minuteStep?, validator? })",
+    example: "gui.inputs.timeInput('meetingTime', { label: 'Meeting time', minuteStep: 15 })",
+    notes: [
+      "Typed time entry (hh:mm segments). Emits an ISO time string (`HH:mm:ss`) — pair with the `{ format: 'time' }` validator. `hourFormat` forces '12'/'24' (default: locale); `minuteStep` sets the arrow-key minute increment."
+    ]
+  },
+  {
+    factory: "timePicker",
+    namespace: "inputs",
+    call: "gui.inputs.timePicker(path, { label, minTime?, maxTime?, minuteStep?, disabledRanges?, allowCustomTime?, validator? })",
+    example: "gui.inputs.timePicker('meetingTime', { label: 'Meeting time', minTime: '09:00', maxTime: '18:00', minuteStep: 30 })",
+    notes: [
+      "Time field with a popover list of slots built from `minTime`..`maxTime` stepping `minuteStep` (default 30). `disabledRanges` (`{ start, end }[]`, inclusive) greys slots out. Typing is off unless `allowCustomTime: true`. Emits `HH:mm:ss` — pair with the `{ format: 'time' }` validator."
+    ]
+  },
+  {
+    factory: "dateTimeInput",
+    namespace: "inputs",
+    call: "gui.inputs.dateTimeInput(path, { label, hourFormat?, minuteStep?, validator? })",
+    example: "gui.inputs.dateTimeInput('meetingAt', { label: 'Meeting at' })",
+    notes: [
+      "Typed date+time entry in one locale-ordered row. Emits a local ISO date-time (`YYYY-MM-DDTHH:mm:ss`) — pair with the `{ format: 'date-time' }` validator. `hourFormat`/`minuteStep` as in `timeInput`."
+    ]
+  },
   {
     factory: "calendar",
     namespace: "inputs",
@@ -375,6 +406,28 @@ const INPUTS = [
       "`minDate` / `maxDate` (ISO `YYYY-MM-DD` strings) constrain the selectable range — see `datePicker`."
     ]
   },
+  {
+    factory: "dateTimeCalendar",
+    namespace: "inputs",
+    call: "gui.inputs.dateTimeCalendar(path, { label, minDate?, maxDate?, minTime?, maxTime?, minuteStep?, disabledTimeRanges?, allowCustomTime? })",
+    example: "gui.inputs.dateTimeCalendar('appointmentAt', { label: 'Appointment', minTime: '09:00', maxTime: '18:00' })",
+    notes: [
+      "An INLINE calendar with an embedded time picker: a segmented time input between the header and the days grid opens a time grid in place of the days (like the year selector).",
+      "Emits a local ISO date-time (`YYYY-MM-DDTHH:mm:ss`) only when BOTH day and time are selected — pair with a `{ type: 'string', format: 'date-time' }` validator. Picking a different day clears the time and resets the value to null.",
+      "`disabledTimeRanges` entries take `start`/`end` ISO times plus optional `date` (ISO date) and/or `weekdays` (getDay() numbering: 0=Sunday … 6=Saturday) to scope the range to specific days."
+    ]
+  },
+  {
+    factory: "dateTimePicker",
+    namespace: "inputs",
+    call: "gui.inputs.dateTimePicker(path, { label, minDate?, maxDate?, minTime?, maxTime?, minuteStep?, disabledTimeRanges?, allowCustomTime? })",
+    example: "gui.inputs.dateTimePicker('appointmentAt', { label: 'Appointment', minTime: '09:00', maxTime: '18:00' })",
+    notes: [
+      "A compact date-time FIELD that opens a `dateTimeCalendar` POPOVER on focus — the space-saving counterpart to the inline `dateTimeCalendar`, like `datePicker` is to `calendar`.",
+      "Emits a local ISO date-time (`YYYY-MM-DDTHH:mm:ss`); the popover closes only when BOTH day and time are selected. Pair with a `{ type: 'string', format: 'date-time' }` validator.",
+      "Takes the same time props as `dateTimeCalendar` (`minTime`/`maxTime`/`minuteStep`/`disabledTimeRanges` with per-date/weekday scoping/`allowCustomTime`) plus `icon` and `invalidDateMessage` for the typed input."
+    ]
+  },
   {
     factory: "markdown",
     namespace: "inputs",
@@ -428,12 +481,60 @@ const INPUTS = [
     example: "gui.inputs.rangeDateInput('stayDates', { label: 'Stay dates' })",
     notes: ["Typed start–end date **range** entry (the range sibling of `dateInput`)."]
   },
+  {
+    factory: "rangeTimeInput",
+    namespace: "inputs",
+    call: "gui.inputs.rangeTimeInput(path, { label?, minTime?, maxTime? })",
+    example: "gui.inputs.rangeTimeInput('shift', { label: 'Shift', minTime: '06:00:00', maxTime: '22:00:00' })",
+    notes: [
+      "Typed start–end time **range** entry (the range sibling of `timeInput`); value is `TimeRange[]`. End time must be after start time."
+    ]
+  },
+  {
+    factory: "rangeDateTimeInput",
+    namespace: "inputs",
+    call: "gui.inputs.rangeDateTimeInput(path, { label?, minDateTime?, maxDateTime? })",
+    example: "gui.inputs.rangeDateTimeInput('window', { label: 'Window', minDateTime: '2026-03-01T06:00:00', maxDateTime: '2026-03-31T22:00:00' })",
+    notes: [
+      "Typed start–end date-time **range** entry (the range sibling of `dateTimeInput`); value is `DateTimeRange[]`. A backward selection reorders (swaps) instead of erroring.",
+      "Each endpoint is an instant, so it is bounded by instants: use **`minDateTime`** / **`maxDateTime`** (ISO `YYYY-MM-DDTHH:mm:ss`), not `minDate`/`maxDate`. There is no `minTime`/`maxTime` here — a per-day time window is a different constraint from an instant bound."
+    ]
+  },
+  {
+    factory: "rangeDateTimeCalendar",
+    namespace: "inputs",
+    call: "gui.inputs.rangeDateTimeCalendar(path, { label?, minDateTime?, maxDateTime?, disabledRanges?, startTimeLabel?, endTimeLabel? })",
+    example: "gui.inputs.rangeDateTimeCalendar('stay', { label: 'Stay', startTimeLabel: 'Check-in', endTimeLabel: 'Check-out' })",
+    notes: [
+      "INLINE range calendar with TWO embedded time pickers (start/end); value is `DateTimeRange[]`, rendered as pills. Pick a date range, then a start time (enables the end time), then an end time to commit a pill. A day holding more than one range shows a count badge.",
+      "Everything is in instant-space: bounds are **`minDateTime`** / **`maxDateTime`** and **`disabledRanges`** are `DateTimeRange[]` instant spans (block a whole day with `00:00:00`–`23:59:59`). There is no `minDate`/`maxDate`/`minTime`/`maxTime`/`disabledTimeRanges` — a time-of-day constraint cannot bound a multi-day span."
+    ]
+  },
+  {
+    factory: "rangeDateTimePicker",
+    namespace: "inputs",
+    call: "gui.inputs.rangeDateTimePicker(path, { label?, minDateTime?, maxDateTime?, disabledRanges?, startTimeLabel?, endTimeLabel? })",
+    example: "gui.inputs.rangeDateTimePicker('stay', { label: 'Stay', startTimeLabel: 'Check-in', endTimeLabel: 'Check-out' })",
+    notes: [
+      "POPOVER date-time range picker: the typed `rangeDateTimeInput` as the trigger (pills live there) with the `rangeDateTimeCalendar` in a dropdown. Value is `DateTimeRange[]`. Committing a pill keeps the popover open so several ranges can be added; it closes on outside-click, blur or Escape.",
+      "Everything is in instant-space: bounds are **`minDateTime`** / **`maxDateTime`** and **`disabledRanges`** are `DateTimeRange[]` instant spans (block a whole day with `00:00:00`–`23:59:59`). There is no `minDate`/`maxDate`/`minTime`/`maxTime`/`disabledTimeRanges`."
+    ]
+  },
   {
     factory: "rangeDatePicker",
     namespace: "inputs",
     call: "gui.inputs.rangeDatePicker(path, { label? })",
     example: "gui.inputs.rangeDatePicker('stayDates', { label: 'Stay dates' })",
     notes: ["Popover calendar for a start–end date **range** (the range sibling of `datePicker`)."]
+  },
+  {
+    factory: "rangeTimePicker",
+    namespace: "inputs",
+    call: "gui.inputs.rangeTimePicker(path, { label?, minTime?, maxTime? })",
+    example: "gui.inputs.rangeTimePicker('shift', { label: 'Shift', minTime: '06:00:00', maxTime: '22:00:00' })",
+    notes: [
+      "Two-list popover for a start–end time **range** (the range sibling of `timePicker`); value is `TimeRange[]`. The out list floors one slot after the chosen in so end is strictly after start."
+    ]
   }
 ];
 const ACTIONS = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@golemui/gui-mcp",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "license": "MIT",
   "description": "Model Context Protocol server for GolemUI — gives AI coding assistants deterministic schema validation and form generation for GolemUI form definitions.",
   "type": "module",
@@ -40,10 +40,10 @@
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "typescript": "^5.9.2",
-    "@golemui/gui-schemas": "1.0.2",
-    "@golemui/gui-shared": "1.0.2",
-    "@golemui/gui-validators": "1.0.2",
-    "@golemui/core": "1.0.2",
+    "@golemui/gui-schemas": "1.1.0",
+    "@golemui/gui-shared": "1.1.0",
+    "@golemui/gui-validators": "1.1.0",
+    "@golemui/core": "1.1.0",
     "zod": "^4.0.0",
     "@standard-schema/spec": "^1.0.0"
   },

package/shared/lint/reactive-expressions.d.ts

@@ -16,6 +16,13 @@ export type ExpressionFinding = {
  * We deliberately don't try to fully parse: too easy to get false positives, too little gain.
  */
 export declare function lintReactiveExpressions(formDefinition: unknown): ExpressionFinding[];
+export type CheckExpressionOptions = {
+    /**
+     * True when the expression lives inside a repeater `props.template`, where the
+     * `$item` and `$index` scope variables are available.
+     */
+    inRepeaterTemplate?: boolean;
+};
 /**
  * Lint a single reactive expression string in isolation, against the same rules
  * `lintReactiveExpressions` applies while walking a JSON form definition. This is
@@ -23,4 +30,4 @@ export declare function lintReactiveExpressions(formDefinition: unknown): Expres
  * object tree, the DX linter has the AST — both funnel each `when` expression
  * through here so the two surfaces can never drift.
  */
-export declare function checkReactiveExpression(expression: string, path?: string): ExpressionFinding[];
+export declare function checkReactiveExpression(expression: string, path?: string, options?: CheckExpressionOptions): ExpressionFinding[];