@neo4j-ndl/react 4.15.2 → 4.15.4

package/lib/cjs/_generated/style-rules/color-utils.js

@@ -0,0 +1,50 @@
+/**
+ *
+ *  Copyright (c) "Neo4j"
+ *  Neo4j Sweden AB [http://neo4j.com]
+ *
+ *  This file is part of Neo4j.
+ *
+ *  Neo4j is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+"use strict";
+/*
+ * AUTO-GENERATED FILE — DO NOT EDIT.
+ * Source of truth: packages/style-rules/src/
+ * Regenerate with `pnpm generate:shared` (runs automatically at build/dev/install).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWeight = getWeight;
+exports.lerpColor = lerpColor;
+/**
+ * Computes a linear interpolation weight in [0, 1] for `value` between
+ * `startValue` and `endValue`. Values outside the range produce weights
+ * outside [0, 1] — callers are responsible for clamping if needed.
+ */
+function getWeight(startValue, endValue, value) {
+    return (value - startValue) / (endValue - startValue);
+}
+/**
+ * Linearly interpolates between two RGB colors by `weight` (0 = start, 1 = end).
+ * Each channel is rounded to the nearest integer.
+ */
+function lerpColor(startColor, endColor, weight) {
+    return {
+        b: Math.round(startColor.b * (1 - weight) + endColor.b * weight),
+        g: Math.round(startColor.g * (1 - weight) + endColor.g * weight),
+        r: Math.round(startColor.r * (1 - weight) + endColor.r * weight),
+    };
+}
+//# sourceMappingURL=color-utils.js.map

package/lib/cjs/_generated/style-rules/color-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"color-utils.js","sourceRoot":"","sources":["../../../../src/_generated/style-rules/color-utils.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;AA8BH,8BAMC;AAMD,8BAUC;AA3BD;;;;GAIG;AACH,SAAgB,SAAS,CACvB,UAAkB,EAClB,QAAgB,EAChB,KAAa;IAEb,OAAO,CAAC,KAAK,GAAG,UAAU,CAAC,GAAG,CAAC,QAAQ,GAAG,UAAU,CAAC,CAAC;AACxD,CAAC;AAED;;;GAGG;AACH,SAAgB,SAAS,CACvB,UAAoB,EACpB,QAAkB,EAClB,MAAc;IAEd,OAAO;QACL,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,QAAQ,CAAC,CAAC,GAAG,MAAM,CAAC;QAChE,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,QAAQ,CAAC,CAAC,GAAG,MAAM,CAAC;QAChE,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,QAAQ,CAAC,CAAC,GAAG,MAAM,CAAC;KACjE,CAAC;AACJ,CAAC","sourcesContent":["/*\n * AUTO-GENERATED FILE — DO NOT EDIT.\n * Source of truth: packages/style-rules/src/\n * Regenerate with `pnpm generate:shared` (runs automatically at build/dev/install).\n */\n\n/**\n *\n *  Copyright (c) \"Neo4j\"\n *  Neo4j Sweden AB [http://neo4j.com]\n *\n *  This file is part of Neo4j.\n *\n *  Neo4j is free software: you can redistribute it and/or modify\n *  it under the terms of the GNU General Public License as published by\n *  the Free Software Foundation, either version 3 of the License, or\n *  (at your option) any later version.\n *\n *  This program is distributed in the hope that it will be useful,\n *  but WITHOUT ANY WARRANTY; without even the implied warranty of\n *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n *  GNU General Public License for more details.\n *\n *  You should have received a copy of the GNU General Public License\n *  along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport type { RgbColor } from '@uiw/react-color';\n\n/**\n * Computes a linear interpolation weight in [0, 1] for `value` between\n * `startValue` and `endValue`. Values outside the range produce weights\n * outside [0, 1] — callers are responsible for clamping if needed.\n */\nexport function getWeight(\n  startValue: number,\n  endValue: number,\n  value: number,\n): number {\n  return (value - startValue) / (endValue - startValue);\n}\n\n/**\n * Linearly interpolates between two RGB colors by `weight` (0 = start, 1 = end).\n * Each channel is rounded to the nearest integer.\n */\nexport function lerpColor(\n  startColor: RgbColor,\n  endColor: RgbColor,\n  weight: number,\n): RgbColor {\n  return {\n    b: Math.round(startColor.b * (1 - weight) + endColor.b * weight),\n    g: Math.round(startColor.g * (1 - weight) + endColor.g * weight),\n    r: Math.round(startColor.r * (1 - weight) + endColor.r * weight),\n  };\n}\n"]}

package/lib/cjs/_generated/style-rules/date-utils.js

@@ -0,0 +1,145 @@
+"use strict";
+/*
+ * AUTO-GENERATED FILE — DO NOT EDIT.
+ * Source of truth: packages/style-rules/src/
+ * Regenerate with `pnpm generate:shared` (runs automatically at build/dev/install).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTimeString = parseTimeString;
+exports.parseDateString = parseDateString;
+/**
+ *
+ *  Copyright (c) "Neo4j"
+ *  Neo4j Sweden AB [http://neo4j.com]
+ *
+ *  This file is part of Neo4j.
+ *
+ *  Neo4j is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+const temporal_polyfill_1 = require("temporal-polyfill");
+const MS_PER_DAY = 86400000;
+function plainTimeToMs(pt) {
+    return (pt.hour * 3600000 +
+        pt.minute * 60000 +
+        pt.second * 1000 +
+        pt.millisecond);
+}
+function parseOffsetMs(offsetStr) {
+    const match = offsetStr.match(/^([+-])(\d{2}):(\d{2})$/);
+    if (!match) {
+        return null;
+    }
+    const sign = match[1] === '+' ? 1 : -1;
+    return (sign *
+        (parseInt(match[2], 10) * 3600000 + parseInt(match[3], 10) * 60000));
+}
+/**
+ * Parses an ISO 8601 time string to UTC milliseconds since midnight
+ * (0–86,399,999). Returns `null` if the string cannot be parsed.
+ *
+ * Three formats are accepted:
+ * 1. Local time (no offset): `"14:30:00"`, `"14:30:00.500"` — treated as UTC
+ * 2. UTC time with Z suffix: `"14:30:00Z"` — treated identically to the local form
+ * 3. Offset time: `"14:30:00+02:00"` — the offset is applied so the result
+ *    is the equivalent UTC time of day. `"12:00:00+01:00"` resolves to
+ *    39,600,000 (11:00 UTC), which is less than `"12:00:00+00:00"` (43,200,000).
+ *
+ * Values wrap around midnight: `"00:00:00+01:00"` → 82,800,000 (23:00 UTC).
+ */
+function parseTimeString(s) {
+    // Reject datetime strings and anything with an IANA timezone bracket.
+    // Temporal.PlainTime.from silently extracts the time portion from strings
+    // containing a 'T' separator. IANA brackets are meaningless for time-only
+    // values (there is no date to anchor DST to), so they are also rejected.
+    if (s.includes('T') || s.includes('[')) {
+        return null;
+    }
+    // Offset time: detect "+HH:MM" or "-HH:MM" suffix first. Temporal.PlainTime.from
+    // silently strips offsets and returns the clock-face time, so we must handle
+    // offset strings explicitly before falling through to the plain parse.
+    const offsetMatch = s.match(/([+-]\d{2}:\d{2})(\[.*\])?$/);
+    if (offsetMatch) {
+        const offsetStr = offsetMatch[1];
+        const timeStr = s.slice(0, s.indexOf(offsetStr));
+        const offsetMs = parseOffsetMs(offsetStr);
+        if (offsetMs !== null) {
+            try {
+                const localMs = plainTimeToMs(temporal_polyfill_1.Temporal.PlainTime.from(timeStr));
+                // Subtract the UTC offset to normalise to UTC time-of-day; wrap around midnight
+                return (((localMs - offsetMs) % MS_PER_DAY) + MS_PER_DAY) % MS_PER_DAY;
+            }
+            catch (_a) {
+                /* empty */
+            }
+        }
+        return null;
+    }
+    // UTC time with Z suffix (e.g. "14:30:00Z") — strip Z and treat as local (UTC) time.
+    // Only apply when there is no 'T' in the string; a datetime string like
+    // "2024-06-15T14:30:00Z" must not be accepted here.
+    const normalized = s.endsWith('Z') && !s.includes('T') ? s.slice(0, -1) : s;
+    // Local time (no offset) — treated as UTC
+    try {
+        return plainTimeToMs(temporal_polyfill_1.Temporal.PlainTime.from(normalized));
+    }
+    catch (_b) {
+        /* empty */
+    }
+    return null;
+}
+/**
+ * Parses an ISO 8601 or RFC 9557 date/datetime string to a Unix millisecond
+ * timestamp. Returns `null` if the string cannot be parsed.
+ *
+ * Three formats are tried in order:
+ * 1. RFC 9557 ZonedDateTime with IANA bracket notation
+ *    e.g. `"2024-06-15T14:00:00[Europe/Stockholm]"` (offset inferred from the
+ *    named timezone, including DST) or `"2024-06-15T14:00:00+02:00[Europe/Stockholm]"`
+ *    (offset explicit; bracket must agree with the IANA zone)
+ * 2. UTC or fixed-offset Instant
+ *    e.g. `"2024-01-01T00:00:00Z"`, `"2024-01-01T00:00:00+02:00"`
+ * 3. Plain date or datetime (no offset, `Z`, or IANA bracket), interpreted as UTC
+ *    e.g. `"2024-01-01"`, `"2024-01-01T14:30:00"`, `"2024-01-01T14:30:00.500"`
+ *
+ * Strings with a time component that lack `Z`, an offset, or an IANA bracket are
+ * parsed as UTC wall-clock time (same semantics as Neo4j `LocalDateTime`).
+ */
+function parseDateString(s) {
+    // RFC 9557 / ZonedDateTime with IANA bracket notation
+    try {
+        return temporal_polyfill_1.Temporal.ZonedDateTime.from(s).epochMilliseconds;
+    }
+    catch (_a) {
+        /* empty */
+    }
+    // UTC or fixed-offset datetime (no IANA name)
+    try {
+        return temporal_polyfill_1.Temporal.Instant.from(s).epochMilliseconds;
+    }
+    catch (_b) {
+        /* empty */
+    }
+    // Plain datetime — interpret as UTC.
+    // Also covers date-only strings like "2024-01-01" (PlainDateTime.from parses
+    // them as midnight), so a separate PlainDate path is not needed.
+    try {
+        return temporal_polyfill_1.Temporal.PlainDateTime.from(s).toZonedDateTime('UTC')
+            .epochMilliseconds;
+    }
+    catch (_c) {
+        /* empty */
+    }
+    return null;
+}
+//# sourceMappingURL=date-utils.js.map

package/lib/cjs/_generated/style-rules/date-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-utils.js","sourceRoot":"","sources":["../../../../src/_generated/style-rules/date-utils.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * AUTO-GENERATED FILE — DO NOT EDIT.\n * Source of truth: packages/style-rules/src/\n * Regenerate with `pnpm generate:shared` (runs automatically at build/dev/install).\n */\n\n/**\n *\n *  Copyright (c) \"Neo4j\"\n *  Neo4j Sweden AB [http://neo4j.com]\n *\n *  This file is part of Neo4j.\n *\n *  Neo4j is free software: you can redistribute it and/or modify\n *  it under the terms of the GNU General Public License as published by\n *  the Free Software Foundation, either version 3 of the License, or\n *  (at your option) any later version.\n *\n *  This program is distributed in the hope that it will be useful,\n *  but WITHOUT ANY WARRANTY; without even the implied warranty of\n *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n *  GNU General Public License for more details.\n *\n *  You should have received a copy of the GNU General Public License\n *  along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { Temporal } from 'temporal-polyfill';\n\nconst MS_PER_DAY = 86_400_000;\n\nfunction plainTimeToMs(pt: Temporal.PlainTime): number {\n  return (\n    pt.hour * 3_600_000 +\n    pt.minute * 60_000 +\n    pt.second * 1_000 +\n    pt.millisecond\n  );\n}\n\nfunction parseOffsetMs(offsetStr: string): number | null {\n  const match = offsetStr.match(/^([+-])(\\d{2}):(\\d{2})$/);\n  if (!match) {\n    return null;\n  }\n  const sign = match[1] === '+' ? 1 : -1;\n  return (\n    sign *\n    (parseInt(match[2], 10) * 3_600_000 + parseInt(match[3], 10) * 60_000)\n  );\n}\n\n/**\n * Parses an ISO 8601 time string to UTC milliseconds since midnight\n * (0–86,399,999). Returns `null` if the string cannot be parsed.\n *\n * Three formats are accepted:\n * 1. Local time (no offset): `\"14:30:00\"`, `\"14:30:00.500\"` — treated as UTC\n * 2. UTC time with Z suffix: `\"14:30:00Z\"` — treated identically to the local form\n * 3. Offset time: `\"14:30:00+02:00\"` — the offset is applied so the result\n *    is the equivalent UTC time of day. `\"12:00:00+01:00\"` resolves to\n *    39,600,000 (11:00 UTC), which is less than `\"12:00:00+00:00\"` (43,200,000).\n *\n * Values wrap around midnight: `\"00:00:00+01:00\"` → 82,800,000 (23:00 UTC).\n */\nexport function parseTimeString(s: string): number | null {\n  // Reject datetime strings and anything with an IANA timezone bracket.\n  // Temporal.PlainTime.from silently extracts the time portion from strings\n  // containing a 'T' separator. IANA brackets are meaningless for time-only\n  // values (there is no date to anchor DST to), so they are also rejected.\n  if (s.includes('T') || s.includes('[')) {\n    return null;\n  }\n  // Offset time: detect \"+HH:MM\" or \"-HH:MM\" suffix first. Temporal.PlainTime.from\n  // silently strips offsets and returns the clock-face time, so we must handle\n  // offset strings explicitly before falling through to the plain parse.\n  const offsetMatch = s.match(/([+-]\\d{2}:\\d{2})(\\[.*\\])?$/);\n  if (offsetMatch) {\n    const offsetStr = offsetMatch[1];\n    const timeStr = s.slice(0, s.indexOf(offsetStr));\n    const offsetMs = parseOffsetMs(offsetStr);\n    if (offsetMs !== null) {\n      try {\n        const localMs = plainTimeToMs(Temporal.PlainTime.from(timeStr));\n        // Subtract the UTC offset to normalise to UTC time-of-day; wrap around midnight\n        return (((localMs - offsetMs) % MS_PER_DAY) + MS_PER_DAY) % MS_PER_DAY;\n      } catch {\n        /* empty */\n      }\n    }\n    return null;\n  }\n\n  // UTC time with Z suffix (e.g. \"14:30:00Z\") — strip Z and treat as local (UTC) time.\n  // Only apply when there is no 'T' in the string; a datetime string like\n  // \"2024-06-15T14:30:00Z\" must not be accepted here.\n  const normalized = s.endsWith('Z') && !s.includes('T') ? s.slice(0, -1) : s;\n\n  // Local time (no offset) — treated as UTC\n  try {\n    return plainTimeToMs(Temporal.PlainTime.from(normalized));\n  } catch {\n    /* empty */\n  }\n\n  return null;\n}\n\n/**\n * Parses an ISO 8601 or RFC 9557 date/datetime string to a Unix millisecond\n * timestamp. Returns `null` if the string cannot be parsed.\n *\n * Three formats are tried in order:\n * 1. RFC 9557 ZonedDateTime with IANA bracket notation\n *    e.g. `\"2024-06-15T14:00:00[Europe/Stockholm]\"` (offset inferred from the\n *    named timezone, including DST) or `\"2024-06-15T14:00:00+02:00[Europe/Stockholm]\"`\n *    (offset explicit; bracket must agree with the IANA zone)\n * 2. UTC or fixed-offset Instant\n *    e.g. `\"2024-01-01T00:00:00Z\"`, `\"2024-01-01T00:00:00+02:00\"`\n * 3. Plain date or datetime (no offset, `Z`, or IANA bracket), interpreted as UTC\n *    e.g. `\"2024-01-01\"`, `\"2024-01-01T14:30:00\"`, `\"2024-01-01T14:30:00.500\"`\n *\n * Strings with a time component that lack `Z`, an offset, or an IANA bracket are\n * parsed as UTC wall-clock time (same semantics as Neo4j `LocalDateTime`).\n */\nexport function parseDateString(s: string): number | null {\n  // RFC 9557 / ZonedDateTime with IANA bracket notation\n  try {\n    return Temporal.ZonedDateTime.from(s).epochMilliseconds;\n  } catch {\n    /* empty */\n  }\n\n  // UTC or fixed-offset datetime (no IANA name)\n  try {\n    return Temporal.Instant.from(s).epochMilliseconds;\n  } catch {\n    /* empty */\n  }\n\n  // Plain datetime — interpret as UTC.\n  // Also covers date-only strings like \"2024-01-01\" (PlainDateTime.from parses\n  // them as midnight), so a separate PlainDate path is not needed.\n  try {\n    return Temporal.PlainDateTime.from(s).toZonedDateTime('UTC')\n      .epochMilliseconds;\n  } catch {\n    /* empty */\n  }\n\n  return null;\n}\n"]}

package/lib/cjs/_generated/style-rules/index.js

@@ -0,0 +1,38 @@
+"use strict";
+/*
+ * AUTO-GENERATED FILE — DO NOT EDIT.
+ * Source of truth: packages/style-rules/src/
+ * Regenerate with `pnpm generate:shared` (runs automatically at build/dev/install).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeLiteralSchema = exports.DatetimeLiteralSchema = exports.parseTimeString = exports.parseDateString = exports.lerpColor = exports.getWeight = void 0;
+/**
+ *
+ *  Copyright (c) "Neo4j"
+ *  Neo4j Sweden AB [http://neo4j.com]
+ *
+ *  This file is part of Neo4j.
+ *
+ *  Neo4j is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+var color_utils_1 = require("./color-utils");
+Object.defineProperty(exports, "getWeight", { enumerable: true, get: function () { return color_utils_1.getWeight; } });
+Object.defineProperty(exports, "lerpColor", { enumerable: true, get: function () { return color_utils_1.lerpColor; } });
+var date_utils_1 = require("./date-utils");
+Object.defineProperty(exports, "parseDateString", { enumerable: true, get: function () { return date_utils_1.parseDateString; } });
+Object.defineProperty(exports, "parseTimeString", { enumerable: true, get: function () { return date_utils_1.parseTimeString; } });
+var literal_schemas_1 = require("./literal-schemas");
+Object.defineProperty(exports, "DatetimeLiteralSchema", { enumerable: true, get: function () { return literal_schemas_1.DatetimeLiteralSchema; } });
+Object.defineProperty(exports, "TimeLiteralSchema", { enumerable: true, get: function () { return literal_schemas_1.TimeLiteralSchema; } });
+//# sourceMappingURL=index.js.map

package/lib/cjs/_generated/style-rules/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/_generated/style-rules/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,6CAAqD;AAA5C,wGAAA,SAAS,OAAA;AAAE,wGAAA,SAAS,OAAA;AAC7B,2CAAgE;AAAvD,6GAAA,eAAe,OAAA;AAAE,6GAAA,eAAe,OAAA;AACzC,qDAA6E;AAApE,wHAAA,qBAAqB,OAAA;AAAE,oHAAA,iBAAiB,OAAA","sourcesContent":["/*\n * AUTO-GENERATED FILE — DO NOT EDIT.\n * Source of truth: packages/style-rules/src/\n * Regenerate with `pnpm generate:shared` (runs automatically at build/dev/install).\n */\n\n/**\n *\n *  Copyright (c) \"Neo4j\"\n *  Neo4j Sweden AB [http://neo4j.com]\n *\n *  This file is part of Neo4j.\n *\n *  Neo4j is free software: you can redistribute it and/or modify\n *  it under the terms of the GNU General Public License as published by\n *  the Free Software Foundation, either version 3 of the License, or\n *  (at your option) any later version.\n *\n *  This program is distributed in the hope that it will be useful,\n *  but WITHOUT ANY WARRANTY; without even the implied warranty of\n *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n *  GNU General Public License for more details.\n *\n *  You should have received a copy of the GNU General Public License\n *  along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nexport { getWeight, lerpColor } from './color-utils';\nexport { parseDateString, parseTimeString } from './date-utils';\nexport { DatetimeLiteralSchema, TimeLiteralSchema } from './literal-schemas';\nexport type { DatetimeLiteral, TimeLiteral } from './literal-schemas';\n"]}

package/lib/cjs/_generated/style-rules/literal-schemas.js

@@ -0,0 +1,64 @@
+"use strict";
+/*
+ * AUTO-GENERATED FILE — DO NOT EDIT.
+ * Source of truth: packages/style-rules/src/
+ * Regenerate with `pnpm generate:shared` (runs automatically at build/dev/install).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeLiteralSchema = exports.DatetimeLiteralSchema = void 0;
+/**
+ *
+ *  Copyright (c) "Neo4j"
+ *  Neo4j Sweden AB [http://neo4j.com]
+ *
+ *  This file is part of Neo4j.
+ *
+ *  Neo4j is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+const zod_1 = require("zod");
+const date_utils_1 = require("./date-utils");
+/**
+ * An ISO 8601 or RFC 9557 datetime literal that resolves to a Unix millisecond
+ * timestamp at evaluation time. Supported formats:
+ * - RFC 9557 with IANA timezone: `"2024-06-15T14:00:00[Europe/Stockholm]"` (offset
+ *   inferred from the named zone, DST-aware) or `"2024-06-15T14:00:00+02:00[Europe/Stockholm]"`
+ *   (offset explicit)
+ * - UTC or offset datetime: `"2024-01-01T00:00:00Z"`, `"2024-01-01T00:00:00+02:00"`
+ * - Plain datetime (treated as UTC): `"2024-01-01T14:30:00"`, `"2024-01-01T14:30:00.500"`
+ * - Date-only (treated as UTC midnight): `"2024-01-01"`
+ */
+exports.DatetimeLiteralSchema = zod_1.z.object({
+    datetime: zod_1.z.string().refine((s) => (0, date_utils_1.parseDateString)(s) !== null, {
+        message: 'datetime must be a valid ISO 8601 / RFC 9557 date or datetime string',
+    }),
+});
+/**
+ * An ISO 8601 time literal that resolves to milliseconds since UTC midnight
+ * at evaluation time. Supported formats:
+ * - Local time (treated as UTC): `"14:30:00"`, `"14:30:00.500"`
+ * - UTC time: `"14:30:00Z"` — identical to local form
+ * - Offset time (UTC-normalised): `"14:30:00+02:00"` → 45,000,000 ms (12:30 UTC)
+ *
+ * IANA timezone brackets (e.g. `[Europe/Stockholm]`) are **not** accepted — a
+ * time-of-day value has no calendar date so DST cannot be resolved. Use
+ * `{ datetime }` literals for timezone-aware instants.
+ *
+ * Full datetime strings (containing `T`) are rejected.
+ */
+exports.TimeLiteralSchema = zod_1.z.object({
+    time: zod_1.z.string().refine((s) => (0, date_utils_1.parseTimeString)(s) !== null, {
+        message: 'time must be a valid ISO 8601 time string (e.g. "14:30:00" or "14:30:00+02:00")',
+    }),
+});
+//# sourceMappingURL=literal-schemas.js.map

package/lib/cjs/_generated/style-rules/literal-schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"literal-schemas.js","sourceRoot":"","sources":["../../../../src/_generated/style-rules/literal-schemas.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,6BAAwB;AAExB,6CAAgE;AAEhE;;;;;;;;;GASG;AACU,QAAA,qBAAqB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC5C,QAAQ,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAA,4BAAe,EAAC,CAAC,CAAC,KAAK,IAAI,EAAE;QAC9D,OAAO,EACL,sEAAsE;KACzE,CAAC;CACH,CAAC,CAAC;AAGH;;;;;;;;;;;;GAYG;AACU,QAAA,iBAAiB,GAAG,OAAC,CAAC,MAAM,CAAC;IACxC,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAA,4BAAe,EAAC,CAAC,CAAC,KAAK,IAAI,EAAE;QAC1D,OAAO,EACL,iFAAiF;KACpF,CAAC;CACH,CAAC,CAAC","sourcesContent":["/*\n * AUTO-GENERATED FILE — DO NOT EDIT.\n * Source of truth: packages/style-rules/src/\n * Regenerate with `pnpm generate:shared` (runs automatically at build/dev/install).\n */\n\n/**\n *\n *  Copyright (c) \"Neo4j\"\n *  Neo4j Sweden AB [http://neo4j.com]\n *\n *  This file is part of Neo4j.\n *\n *  Neo4j is free software: you can redistribute it and/or modify\n *  it under the terms of the GNU General Public License as published by\n *  the Free Software Foundation, either version 3 of the License, or\n *  (at your option) any later version.\n *\n *  This program is distributed in the hope that it will be useful,\n *  but WITHOUT ANY WARRANTY; without even the implied warranty of\n *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n *  GNU General Public License for more details.\n *\n *  You should have received a copy of the GNU General Public License\n *  along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { z } from 'zod';\n\nimport { parseDateString, parseTimeString } from './date-utils';\n\n/**\n * An ISO 8601 or RFC 9557 datetime literal that resolves to a Unix millisecond\n * timestamp at evaluation time. Supported formats:\n * - RFC 9557 with IANA timezone: `\"2024-06-15T14:00:00[Europe/Stockholm]\"` (offset\n *   inferred from the named zone, DST-aware) or `\"2024-06-15T14:00:00+02:00[Europe/Stockholm]\"`\n *   (offset explicit)\n * - UTC or offset datetime: `\"2024-01-01T00:00:00Z\"`, `\"2024-01-01T00:00:00+02:00\"`\n * - Plain datetime (treated as UTC): `\"2024-01-01T14:30:00\"`, `\"2024-01-01T14:30:00.500\"`\n * - Date-only (treated as UTC midnight): `\"2024-01-01\"`\n */\nexport const DatetimeLiteralSchema = z.object({\n  datetime: z.string().refine((s) => parseDateString(s) !== null, {\n    message:\n      'datetime must be a valid ISO 8601 / RFC 9557 date or datetime string',\n  }),\n});\nexport type DatetimeLiteral = z.infer<typeof DatetimeLiteralSchema>;\n\n/**\n * An ISO 8601 time literal that resolves to milliseconds since UTC midnight\n * at evaluation time. Supported formats:\n * - Local time (treated as UTC): `\"14:30:00\"`, `\"14:30:00.500\"`\n * - UTC time: `\"14:30:00Z\"` — identical to local form\n * - Offset time (UTC-normalised): `\"14:30:00+02:00\"` → 45,000,000 ms (12:30 UTC)\n *\n * IANA timezone brackets (e.g. `[Europe/Stockholm]`) are **not** accepted — a\n * time-of-day value has no calendar date so DST cannot be resolved. Use\n * `{ datetime }` literals for timezone-aware instants.\n *\n * Full datetime strings (containing `T`) are rejected.\n */\nexport const TimeLiteralSchema = z.object({\n  time: z.string().refine((s) => parseTimeString(s) !== null, {\n    message:\n      'time must be a valid ISO 8601 time string (e.g. \"14:30:00\" or \"14:30:00+02:00\")',\n  }),\n});\nexport type TimeLiteral = z.infer<typeof TimeLiteralSchema>;\n"]}

package/lib/cjs/data-grid/stories/datagrid-rule-based-styling-datetime.story.js

@@ -0,0 +1,286 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+/**
+ *
+ *  Copyright (c) "Neo4j"
+ *  Neo4j Sweden AB [http://neo4j.com]
+ *
+ *  This file is part of Neo4j.
+ *
+ *  Neo4j is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+require("@neo4j-ndl/base/lib/neo4j-ds-styles.css");
+const react_1 = require("@neo4j-ndl/react");
+const react_table_1 = require("@tanstack/react-table");
+const data = [
+    // ── Past events (before start of 2026-06-25 in Stockholm / CEST) ──────────
+    {
+        event: 'Quarterly review',
+        // 09:00 Stockholm CEST = 07:00 UTC
+        scheduledDate: new Date('2026-06-10T09:00:00+02:00'),
+        scheduledTimeMs: 7 * 3600000,
+        localTimeDisplay: '09:00 CEST (+02:00)',
+        status: 'confirmed',
+    },
+    {
+        event: 'Security audit',
+        // 07:30 London BST (+01:00) = 06:30 UTC — before Stockholm opens
+        scheduledDate: new Date('2026-06-18T07:30:00+01:00'),
+        scheduledTimeMs: 6 * 3600000 + 30 * 60000,
+        localTimeDisplay: '07:30 BST (+01:00)',
+        status: 'delayed',
+    },
+    // ── Today (2026-06-25 in Stockholm / CEST) ─────────────────────────────────
+    {
+        event: 'Customer demo',
+        // 09:00 New York EDT (-04:00) = 13:00 UTC
+        scheduledDate: new Date('2026-06-25T09:00:00-04:00'),
+        scheduledTimeMs: 13 * 3600000,
+        localTimeDisplay: '09:00 EDT (-04:00)',
+        status: 'confirmed',
+    },
+    {
+        event: 'Platform migration',
+        // 22:00 Stockholm CEST (+02:00) = 20:00 UTC — after Stockholm closes
+        scheduledDate: new Date('2026-06-25T22:00:00+02:00'),
+        scheduledTimeMs: 20 * 3600000,
+        localTimeDisplay: '22:00 CEST (+02:00)',
+        status: 'confirmed',
+    },
+    // ── Near future (up to and including 2026-07-14 in Stockholm) ─────────────
+    {
+        event: 'Board presentation',
+        // 10:00 Singapore SGT (+08:00) = 02:00 UTC — before Stockholm opens
+        scheduledDate: new Date('2026-07-02T10:00:00+08:00'),
+        scheduledTimeMs: 2 * 3600000,
+        localTimeDisplay: '10:00 SGT (+08:00)',
+        status: 'confirmed',
+    },
+    {
+        event: 'Partner onboarding',
+        // 13:15 Paris CEST (+02:00) = 11:15 UTC
+        scheduledDate: new Date('2026-07-08T13:15:00+02:00'),
+        scheduledTimeMs: 11 * 3600000 + 15 * 60000,
+        localTimeDisplay: '13:15 CEST (+02:00)',
+        status: 'cancelled',
+    },
+    // ── Far future (after 2026-07-15T00:00 Stockholm / CEST = 2026-07-14T22:00Z)
+    {
+        event: 'Architecture summit',
+        // 08:00 Amsterdam CEST (+02:00) = 06:00 UTC.
+        // Although the calendar date is "July 15", 08:00 CEST is still within the
+        // same UTC day as July 14 22:00Z, so it crosses the far-future boundary.
+        scheduledDate: new Date('2026-07-15T08:00:00+02:00'),
+        scheduledTimeMs: 6 * 3600000,
+        localTimeDisplay: '08:00 CEST (+02:00)',
+        status: 'confirmed',
+    },
+    {
+        event: 'Annual conference',
+        // 09:00 San Francisco PDT (-07:00) = 16:00 UTC — after Stockholm closes
+        scheduledDate: new Date('2026-08-03T09:00:00-07:00'),
+        scheduledTimeMs: 16 * 3600000,
+        localTimeDisplay: '09:00 PDT (-07:00)',
+        status: 'confirmed',
+    },
+    {
+        event: 'Year-end planning',
+        // 09:00 Tokyo JST (+09:00) = 00:00 UTC — midnight, well before Stockholm opens
+        scheduledDate: new Date('2026-11-20T09:00:00+09:00'),
+        scheduledTimeMs: 0,
+        localTimeDisplay: '09:00 JST (+09:00)',
+        status: 'confirmed',
+    },
+];
+/**
+ * All date and time boundaries are anchored to Stockholm in June–July 2026.
+ * Date literals use RFC 9557 IANA bracket notation — the UTC offset is inferred
+ * from the named zone (CEST = +02:00 in this period); writing `+02:00` explicitly
+ * is optional. Time literals use UTC-offset notation.
+ *
+ * "Today" from a Stockholm perspective:
+ *   2026-06-25T00:00:00[Europe/Stockholm] = 2026-06-24T22:00:00Z
+ *   2026-06-26T00:00:00[Europe/Stockholm] = 2026-06-25T22:00:00Z
+ *
+ * "Far future" threshold:
+ *   2026-07-15T00:00:00[Europe/Stockholm] = 2026-07-14T22:00:00Z
+ *
+ * Business hours (Stockholm):
+ *   { time: '09:00:00+02:00' } resolves to 07:00 UTC (25 200 000 ms)
+ *   { time: '17:00:00+02:00' } resolves to 15:00 UTC (54 000 000 ms)
+ */
+const styleRules = [
+    // Past events — entire row in muted red
+    {
+        apply: {
+            color: { value: '#fee2e2' },
+            textColor: { value: '#7f1d1d' },
+        },
+        column: null,
+        priority: 1,
+        where: {
+            lessThan: [
+                { column: 'scheduledDate' },
+                { datetime: '2026-06-25T00:00:00[Europe/Stockholm]' },
+            ],
+        },
+    },
+    // Today (in Stockholm timezone) — entire row in amber
+    {
+        apply: {
+            color: { value: '#fef9c3' },
+            textColor: { value: '#713f12' },
+        },
+        column: null,
+        priority: 1,
+        where: {
+            and: [
+                {
+                    greaterThanOrEqual: [
+                        { column: 'scheduledDate' },
+                        { datetime: '2026-06-25T00:00:00[Europe/Stockholm]' },
+                    ],
+                },
+                {
+                    lessThan: [
+                        { column: 'scheduledDate' },
+                        { datetime: '2026-06-26T00:00:00[Europe/Stockholm]' },
+                    ],
+                },
+            ],
+        },
+    },
+    // Far future (after 2026-07-15 midnight Stockholm time) — entire row in green
+    {
+        apply: {
+            color: { value: '#dcfce7' },
+            textColor: { value: '#14532d' },
+        },
+        column: null,
+        priority: 1,
+        where: {
+            greaterThanOrEqual: [
+                { column: 'scheduledDate' },
+                { datetime: '2026-07-15T00:00:00[Europe/Stockholm]' },
+            ],
+        },
+    },
+    // Outside Stockholm business hours (before 09:00 CEST or from 17:00 CEST) —
+    // time cell in orange. The { time: "..." } literals carry an offset so the
+    // engine normalises them to UTC before comparing against scheduledTimeMs.
+    {
+        apply: {
+            color: { value: '#ffedd5' },
+            textColor: { value: '#7c2d12' },
+        },
+        column: 'scheduledTimeMs',
+        priority: 2,
+        where: {
+            or: [
+                {
+                    lessThan: [{ column: 'scheduledTimeMs' }, { time: '09:00:00+02:00' }],
+                },
+                {
+                    greaterThanOrEqual: [
+                        { column: 'scheduledTimeMs' },
+                        { time: '17:00:00+02:00' },
+                    ],
+                },
+            ],
+        },
+    },
+    // Cancelled events — all cells grayed out at highest priority
+    {
+        apply: {
+            color: { value: '#f3f4f6' },
+            textColor: { value: '#9ca3af' },
+        },
+        column: null,
+        priority: 5,
+        where: { equal: [{ column: 'status' }, 'cancelled'] },
+    },
+];
+const Component = () => {
+    const columnHelper = (0, react_table_1.createColumnHelper)();
+    const columns = [
+        columnHelper.accessor('event', {
+            cell: (info) => info.getValue(),
+            header: () => 'Event',
+            minSize: 180,
+            size: 220,
+        }),
+        columnHelper.accessor('scheduledDate', {
+            cell: (info) => info.getValue().toLocaleDateString('en-GB', {
+                day: 'numeric',
+                month: 'short',
+                timeZone: 'Europe/Stockholm',
+                year: 'numeric',
+            }),
+            header: () => 'Date (Stockholm)',
+            minSize: 150,
+            size: 170,
+        }),
+        columnHelper.accessor('localTimeDisplay', {
+            cell: (info) => info.getValue(),
+            header: () => 'Local time',
+            minSize: 160,
+            size: 180,
+        }),
+        columnHelper.accessor('scheduledTimeMs', {
+            cell: (info) => {
+                const ms = info.getValue();
+                const h = Math.floor(ms / 3600000)
+                    .toString()
+                    .padStart(2, '0');
+                const m = Math.floor((ms % 3600000) / 60000)
+                    .toString()
+                    .padStart(2, '0');
+                return `${h}:${m} UTC`;
+            },
+            header: () => 'Time (UTC)',
+            minSize: 110,
+            size: 130,
+        }),
+        columnHelper.accessor('status', {
+            cell: (info) => info.getValue(),
+            header: () => 'Status',
+            minSize: 100,
+            size: 120,
+        }),
+    ];
+    const table = (0, react_table_1.useReactTable)({
+        columnResizeMode: 'onChange',
+        columns,
+        data,
+        defaultColumn: {
+            maxSize: 800,
+            minSize: 80,
+        },
+        enableSorting: true,
+        getCoreRowModel: (0, react_table_1.getCoreRowModel)(),
+        getPaginationRowModel: (0, react_table_1.getPaginationRowModel)(),
+        getSortedRowModel: (0, react_table_1.getSortedRowModel)(),
+        initialState: {
+            pagination: { pageSize: 10 },
+        },
+    });
+    return ((0, jsx_runtime_1.jsx)("div", { className: "n-w-full n-bg-light-neutral-text-weakest", children: (0, jsx_runtime_1.jsx)(react_1.DataGrid, { isResizable: false, isKeyboardNavigable: false, tableInstance: table, styleRules: styleRules, styling: {
+                borderStyle: 'all-sides',
+                hasHoverEffects: true,
+                hasZebraStriping: false,
+            } }) }));
+};
+exports.default = Component;
+//# sourceMappingURL=datagrid-rule-based-styling-datetime.story.js.map