@neo4j-ndl/react 4.25.10 → 5.0.0-alpha.0.b2b2481

package/lib/esm/data-grid/style-rules/internal/schemas.js

@@ -0,0 +1,210 @@
+/*!
+ *
+ *  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/>.
+ */
+import { z } from 'zod';
+import { BigintLiteralSchema, DatetimeLiteralSchema, LocalDatetimeLiteralSchema, NumericLiteralSchema, RangeLiteralSchema, TimeLiteralSchema, } from '../../../_generated/style-rules/literal-schemas';
+/*
+ * Internal only. Do NOT re-export these schemas. They are only the runtime
+ * backing for `isDataGridStyleRule`; the public contract is the hand-written
+ * types in `../types.ts`. We should never export a Zod schema since it would
+ * force consumers onto our Zod version.
+ *
+ * Every schema is anchored to its type with `satisfies` so editing one without
+ * the other fails the build.
+ */
+/**
+ * A literal value used in style-rule where clauses, converter return values,
+ * and cell data. Temporal wrappers resolve to numbers at evaluation time.
+ */
+export const DataGridStyleRuleLiteralSchema = z.union([
+    z.string(),
+    NumericLiteralSchema,
+    z.boolean(),
+    z.null(),
+    DatetimeLiteralSchema,
+    LocalDatetimeLiteralSchema,
+    TimeLiteralSchema,
+]);
+/** A JSON-safe bigint literal represented by a signed decimal string. */
+export const DataGridBigintLiteralSchema = BigintLiteralSchema;
+/** A number, native bigint, or JSON-safe bigint literal. */
+export const DataGridNumericLiteralSchema = NumericLiteralSchema;
+/** A numeric, datetime, localdatetime, or time literal used as a range boundary. */
+export const DataGridRangeLiteralSchema = RangeLiteralSchema;
+/** A reference to a column whose cell value is resolved at evaluation time. */
+export const DataGridColumnRefSchema = z.object({
+    column: z.string(),
+});
+/**
+ * An ISO 8601 or RFC 9557 datetime literal that resolves to a Unix millisecond
+ * timestamp at evaluation time. Wraps the shared `DatetimeLiteralSchema` with a
+ * DataGrid-specific name. Supported formats:
+ * - RFC 9557 with IANA timezone: `"2024-06-15T14:00:00[Europe/Stockholm]"` (offset
+ *   inferred) 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"`
+ * - Date-only (treated as UTC midnight): `"2024-01-01"`
+ *
+ * Unzoned datetimes without `Z` or an offset are treated as UTC wall-clock time.
+ */
+export const DataGridDatetimeLiteralSchema = DatetimeLiteralSchema;
+/**
+ * A plain (unzoned) ISO 8601 date or datetime literal that resolves to a Unix
+ * millisecond timestamp in the browser's local timezone at evaluation time.
+ * Wraps the shared `LocalDatetimeLiteralSchema` with a DataGrid-specific name.
+ *
+ * Only plain date/datetime strings without timezone qualifiers are accepted:
+ * - Plain datetime: `"2024-01-01T14:30:00"`
+ * - Date-only (treated as local midnight): `"2024-01-01"`
+ *
+ * Strings with `Z`, a UTC offset, or an IANA bracket are rejected — use
+ * `{ datetime }` for timezone-aware instants.
+ */
+export const DataGridLocalDatetimeLiteralSchema = LocalDatetimeLiteralSchema;
+/**
+ * An ISO 8601 time literal that resolves to milliseconds since UTC midnight at
+ * evaluation time. Wraps the shared `TimeLiteralSchema` with a DataGrid-specific
+ * name. Supported formats:
+ * - Local time (treated as UTC): `"14:30:00"`, `"14:30:00.500"`
+ * - Offset time (UTC-normalised): `"14:30:00+02:00"`
+ */
+export const DataGridTimeLiteralSchema = TimeLiteralSchema;
+/** An operand in a style-rule where clause -- either a literal value or a column reference. */
+export const DataGridStyleRuleOperandSchema = z.union([
+    DataGridColumnRefSchema,
+    DataGridStyleRuleLiteralSchema,
+]);
+export const DataGridStyleRuleWhereSchema = z.lazy(() => z.union([
+    z.object({ not: DataGridStyleRuleWhereSchema }),
+    z.object({ and: z.array(DataGridStyleRuleWhereSchema) }),
+    z.object({ or: z.array(DataGridStyleRuleWhereSchema) }),
+    z.object({
+        equal: z.tuple([
+            DataGridStyleRuleOperandSchema,
+            DataGridStyleRuleOperandSchema,
+        ]),
+    }),
+    z.object({
+        lessThan: z.tuple([
+            DataGridStyleRuleOperandSchema,
+            DataGridStyleRuleOperandSchema,
+        ]),
+    }),
+    z.object({
+        lessThanOrEqual: z.tuple([
+            DataGridStyleRuleOperandSchema,
+            DataGridStyleRuleOperandSchema,
+        ]),
+    }),
+    z.object({
+        greaterThan: z.tuple([
+            DataGridStyleRuleOperandSchema,
+            DataGridStyleRuleOperandSchema,
+        ]),
+    }),
+    z.object({
+        greaterThanOrEqual: z.tuple([
+            DataGridStyleRuleOperandSchema,
+            DataGridStyleRuleOperandSchema,
+        ]),
+    }),
+    z.object({
+        contains: z.tuple([
+            DataGridStyleRuleOperandSchema,
+            DataGridStyleRuleOperandSchema,
+        ]),
+    }),
+    z.object({
+        startsWith: z.tuple([
+            DataGridStyleRuleOperandSchema,
+            DataGridStyleRuleOperandSchema,
+        ]),
+    }),
+    z.object({
+        endsWith: z.tuple([
+            DataGridStyleRuleOperandSchema,
+            DataGridStyleRuleOperandSchema,
+        ]),
+    }),
+    z.object({ isNull: DataGridStyleRuleOperandSchema }),
+]));
+/**
+ * Gradient coloring based on a continuous orderable column value.
+ * Colors should be hex strings (#rrggbb).
+ * Temporal range boundaries resolve to numbers before interpolation.
+ * If the column value is missing or non-orderable, the colorRange is ignored.
+ */
+export const DataGridColorRangeSchema = z.object({
+    /** Disable this color range without removing it. */
+    isDisabled: z.boolean().optional(),
+    /** Hex color (#rrggbb) at the maximum value. */
+    maxColor: z.string(),
+    /** The high end of the range. Values above this clamp to maxColor. */
+    maxValue: DataGridRangeLiteralSchema,
+    /** Hex color (#rrggbb) at the optional mid-point for a 3-stop gradient. */
+    midColor: z.string().optional(),
+    /** Optional inflection point between minValue and maxValue for a 3-stop gradient. */
+    midValue: DataGridRangeLiteralSchema.optional(),
+    /** Hex color (#rrggbb) at the minimum value. */
+    minColor: z.string(),
+    /** The low end of the range. Values below this clamp to minColor. */
+    minValue: DataGridRangeLiteralSchema,
+    /** The column whose orderable value drives the interpolation. */
+    onColumn: z.string(),
+});
+/** A disable-able static color value. */
+export const DataGridDisableableColorSchema = z.object({
+    /** Disable this style without removing it. */
+    isDisabled: z.boolean().optional(),
+    /** The CSS color value (e.g. '#fee2e2'). */
+    value: z.string(),
+});
+/** Visual properties that a style rule can apply to a cell or row. */
+export const DataGridCellStyleSchema = z.object({
+    /** CSS background color / cell fill (e.g. '#fee2e2'). Matches the graph `Style.color`. */
+    color: DataGridDisableableColorSchema.optional(),
+    /** Gradient color interpolation applied to the cell fill. Matches the graph `Style.colorRange`. */
+    colorRange: DataGridColorRangeSchema.optional(),
+    /** CSS text color (e.g. '#991b1b'). Grid-only; no graph equivalent. */
+    textColor: DataGridDisableableColorSchema.optional(),
+    /** Gradient color interpolation applied to the text color. Grid-only; no graph equivalent. */
+    textColorRange: DataGridColorRangeSchema.optional(),
+});
+/**
+ * metaData is an free-form object that can be used to store additional information about a style rule.
+ * The data is not taken into account when evaluating the rule.
+ */
+const metaDataSchema = z.record(z.string(), z.unknown());
+/** A single declarative rule that conditionally applies styles to DataGrid cells. */
+export const DataGridStyleRuleSchema = z.object({
+    /** Style properties to apply when the rule matches. */
+    apply: DataGridCellStyleSchema,
+    /** Which column this rule targets. Set to null to apply styles to all columns (row-level effect). */
+    column: z.string().nullable(),
+    /** Disable this rule without removing it. */
+    isDisabled: z.boolean().optional(),
+    /** Additional metadata about the rule. */
+    metaData: metaDataSchema.optional(),
+    /** Higher priority rules are applied later (override lower). Must be `>= 0`; negative values are reserved for internal use. Rules without explicit priority preserve their array order but are always applied before rules with explicit priority. */
+    priority: z.number().nonnegative().optional(),
+    /** Condition to evaluate. If omitted, rule always applies to matched column(s). */
+    where: DataGridStyleRuleWhereSchema.optional(),
+});
+//# sourceMappingURL=schemas.js.map

package/lib/esm/data-grid/style-rules/internal/schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../../../../../src/data-grid/style-rules/internal/schemas.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\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 {\n  BigintLiteralSchema,\n  DatetimeLiteralSchema,\n  LocalDatetimeLiteralSchema,\n  NumericLiteralSchema,\n  RangeLiteralSchema,\n  TimeLiteralSchema,\n} from '../../../_generated/style-rules/literal-schemas';\nimport type {\n  DataGridCellStyle,\n  DataGridColorRange,\n  DataGridColumnRef,\n  DataGridDisableableColor,\n  DataGridStyleRule,\n  DataGridStyleRuleLiteral,\n  DataGridStyleRuleOperand,\n  DataGridStyleRuleWhere,\n} from '../types';\n\n/*\n * Internal only. Do NOT re-export these schemas. They are only the runtime\n * backing for `isDataGridStyleRule`; the public contract is the hand-written\n * types in `../types.ts`. We should never export a Zod schema since it would\n * force consumers onto our Zod version.\n *\n * Every schema is anchored to its type with `satisfies` so editing one without\n * the other fails the build.\n */\n\n/**\n * A literal value used in style-rule where clauses, converter return values,\n * and cell data. Temporal wrappers resolve to numbers at evaluation time.\n */\nexport const DataGridStyleRuleLiteralSchema = z.union([\n  z.string(),\n  NumericLiteralSchema,\n  z.boolean(),\n  z.null(),\n  DatetimeLiteralSchema,\n  LocalDatetimeLiteralSchema,\n  TimeLiteralSchema,\n]) satisfies z.ZodType<DataGridStyleRuleLiteral>;\n\n/** A JSON-safe bigint literal represented by a signed decimal string. */\nexport const DataGridBigintLiteralSchema = BigintLiteralSchema;\n\n/** A number, native bigint, or JSON-safe bigint literal. */\nexport const DataGridNumericLiteralSchema = NumericLiteralSchema;\n\n/** A numeric, datetime, localdatetime, or time literal used as a range boundary. */\nexport const DataGridRangeLiteralSchema = RangeLiteralSchema;\n\n/** A reference to a column whose cell value is resolved at evaluation time. */\nexport const DataGridColumnRefSchema = z.object({\n  column: z.string(),\n}) satisfies z.ZodType<DataGridColumnRef>;\n\n/**\n * An ISO 8601 or RFC 9557 datetime literal that resolves to a Unix millisecond\n * timestamp at evaluation time. Wraps the shared `DatetimeLiteralSchema` with a\n * DataGrid-specific name. Supported formats:\n * - RFC 9557 with IANA timezone: `\"2024-06-15T14:00:00[Europe/Stockholm]\"` (offset\n *   inferred) or `\"2024-06-15T14:00:00+02:00[Europe/Stockholm]\"` (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\"`\n * - Date-only (treated as UTC midnight): `\"2024-01-01\"`\n *\n * Unzoned datetimes without `Z` or an offset are treated as UTC wall-clock time.\n */\nexport const DataGridDatetimeLiteralSchema = DatetimeLiteralSchema;\n\n/**\n * A plain (unzoned) ISO 8601 date or datetime literal that resolves to a Unix\n * millisecond timestamp in the browser's local timezone at evaluation time.\n * Wraps the shared `LocalDatetimeLiteralSchema` with a DataGrid-specific name.\n *\n * Only plain date/datetime strings without timezone qualifiers are accepted:\n * - Plain datetime: `\"2024-01-01T14:30:00\"`\n * - Date-only (treated as local midnight): `\"2024-01-01\"`\n *\n * Strings with `Z`, a UTC offset, or an IANA bracket are rejected — use\n * `{ datetime }` for timezone-aware instants.\n */\nexport const DataGridLocalDatetimeLiteralSchema = LocalDatetimeLiteralSchema;\n\n/**\n * An ISO 8601 time literal that resolves to milliseconds since UTC midnight at\n * evaluation time. Wraps the shared `TimeLiteralSchema` with a DataGrid-specific\n * name. Supported formats:\n * - Local time (treated as UTC): `\"14:30:00\"`, `\"14:30:00.500\"`\n * - Offset time (UTC-normalised): `\"14:30:00+02:00\"`\n */\nexport const DataGridTimeLiteralSchema = TimeLiteralSchema;\n\n/** An operand in a style-rule where clause -- either a literal value or a column reference. */\nexport const DataGridStyleRuleOperandSchema = z.union([\n  DataGridColumnRefSchema,\n  DataGridStyleRuleLiteralSchema,\n]) satisfies z.ZodType<DataGridStyleRuleOperand>;\n\nexport const DataGridStyleRuleWhereSchema: z.ZodType<DataGridStyleRuleWhere> =\n  z.lazy(() =>\n    z.union([\n      z.object({ not: DataGridStyleRuleWhereSchema }),\n      z.object({ and: z.array(DataGridStyleRuleWhereSchema) }),\n      z.object({ or: z.array(DataGridStyleRuleWhereSchema) }),\n      z.object({\n        equal: z.tuple([\n          DataGridStyleRuleOperandSchema,\n          DataGridStyleRuleOperandSchema,\n        ]),\n      }),\n      z.object({\n        lessThan: z.tuple([\n          DataGridStyleRuleOperandSchema,\n          DataGridStyleRuleOperandSchema,\n        ]),\n      }),\n      z.object({\n        lessThanOrEqual: z.tuple([\n          DataGridStyleRuleOperandSchema,\n          DataGridStyleRuleOperandSchema,\n        ]),\n      }),\n      z.object({\n        greaterThan: z.tuple([\n          DataGridStyleRuleOperandSchema,\n          DataGridStyleRuleOperandSchema,\n        ]),\n      }),\n      z.object({\n        greaterThanOrEqual: z.tuple([\n          DataGridStyleRuleOperandSchema,\n          DataGridStyleRuleOperandSchema,\n        ]),\n      }),\n      z.object({\n        contains: z.tuple([\n          DataGridStyleRuleOperandSchema,\n          DataGridStyleRuleOperandSchema,\n        ]),\n      }),\n      z.object({\n        startsWith: z.tuple([\n          DataGridStyleRuleOperandSchema,\n          DataGridStyleRuleOperandSchema,\n        ]),\n      }),\n      z.object({\n        endsWith: z.tuple([\n          DataGridStyleRuleOperandSchema,\n          DataGridStyleRuleOperandSchema,\n        ]),\n      }),\n      z.object({ isNull: DataGridStyleRuleOperandSchema }),\n    ]),\n  );\n\n/**\n * Gradient coloring based on a continuous orderable column value.\n * Colors should be hex strings (#rrggbb).\n * Temporal range boundaries resolve to numbers before interpolation.\n * If the column value is missing or non-orderable, the colorRange is ignored.\n */\nexport const DataGridColorRangeSchema = z.object({\n  /** Disable this color range without removing it. */\n  isDisabled: z.boolean().optional(),\n  /** Hex color (#rrggbb) at the maximum value. */\n  maxColor: z.string(),\n  /** The high end of the range. Values above this clamp to maxColor. */\n  maxValue: DataGridRangeLiteralSchema,\n  /** Hex color (#rrggbb) at the optional mid-point for a 3-stop gradient. */\n  midColor: z.string().optional(),\n  /** Optional inflection point between minValue and maxValue for a 3-stop gradient. */\n  midValue: DataGridRangeLiteralSchema.optional(),\n  /** Hex color (#rrggbb) at the minimum value. */\n  minColor: z.string(),\n  /** The low end of the range. Values below this clamp to minColor. */\n  minValue: DataGridRangeLiteralSchema,\n  /** The column whose orderable value drives the interpolation. */\n  onColumn: z.string(),\n}) satisfies z.ZodType<DataGridColorRange>;\n\n/** A disable-able static color value. */\nexport const DataGridDisableableColorSchema = z.object({\n  /** Disable this style without removing it. */\n  isDisabled: z.boolean().optional(),\n  /** The CSS color value (e.g. '#fee2e2'). */\n  value: z.string(),\n}) satisfies z.ZodType<DataGridDisableableColor>;\n\n/** Visual properties that a style rule can apply to a cell or row. */\nexport const DataGridCellStyleSchema = z.object({\n  /** CSS background color / cell fill (e.g. '#fee2e2'). Matches the graph `Style.color`. */\n  color: DataGridDisableableColorSchema.optional(),\n  /** Gradient color interpolation applied to the cell fill. Matches the graph `Style.colorRange`. */\n  colorRange: DataGridColorRangeSchema.optional(),\n  /** CSS text color (e.g. '#991b1b'). Grid-only; no graph equivalent. */\n  textColor: DataGridDisableableColorSchema.optional(),\n  /** Gradient color interpolation applied to the text color. Grid-only; no graph equivalent. */\n  textColorRange: DataGridColorRangeSchema.optional(),\n}) satisfies z.ZodType<DataGridCellStyle>;\n\n/**\n * metaData is an free-form object that can be used to store additional information about a style rule.\n * The data is not taken into account when evaluating the rule.\n */\nconst metaDataSchema = z.record(z.string(), z.unknown());\n\n/** A single declarative rule that conditionally applies styles to DataGrid cells. */\nexport const DataGridStyleRuleSchema = z.object({\n  /** Style properties to apply when the rule matches. */\n  apply: DataGridCellStyleSchema,\n  /** Which column this rule targets. Set to null to apply styles to all columns (row-level effect). */\n  column: z.string().nullable(),\n  /** Disable this rule without removing it. */\n  isDisabled: z.boolean().optional(),\n  /** Additional metadata about the rule. */\n  metaData: metaDataSchema.optional(),\n  /** Higher priority rules are applied later (override lower). Must be `>= 0`; negative values are reserved for internal use. Rules without explicit priority preserve their array order but are always applied before rules with explicit priority. */\n  priority: z.number().nonnegative().optional(),\n  /** Condition to evaluate. If omitted, rule always applies to matched column(s). */\n  where: DataGridStyleRuleWhereSchema.optional(),\n}) satisfies z.ZodType<DataGridStyleRule>;\n"]}

package/lib/esm/data-grid/style-rules/types.js

@@ -18,207 +18,5 @@
  *  You should have received a copy of the GNU General Public License
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-import { z } from 'zod';
-import { BigintLiteralSchema, DatetimeLiteralSchema, LocalDatetimeLiteralSchema, NumericLiteralSchema, RangeLiteralSchema, TimeLiteralSchema, } from '../../_generated/style-rules';
-/*
- * Style types defined in Zod, so that we can use the schemas to generate JSON Schema.
- * This is useful for generating documentation, importing and for future integration into editors.
- */
-/**
- * A literal value used in style-rule where clauses, converter return values,
- * and cell data. Temporal wrappers resolve to numbers at evaluation time.
- */
-export const DataGridStyleRuleLiteralSchema = z.union([
-    z.string(),
-    NumericLiteralSchema,
-    z.boolean(),
-    z.null(),
-    DatetimeLiteralSchema,
-    LocalDatetimeLiteralSchema,
-    TimeLiteralSchema,
-]);
-/** A JSON-safe bigint literal represented by a signed decimal string. */
-export const DataGridBigintLiteralSchema = BigintLiteralSchema;
-/** A number, native bigint, or JSON-safe bigint literal. */
-export const DataGridNumericLiteralSchema = NumericLiteralSchema;
-/** A numeric, datetime, localdatetime, or time literal used as a range boundary. */
-export const DataGridRangeLiteralSchema = RangeLiteralSchema;
-/** A reference to a column whose cell value is resolved at evaluation time. */
-export const DataGridColumnRefSchema = z.object({ column: z.string() });
-/**
- * An ISO 8601 or RFC 9557 datetime literal that resolves to a Unix millisecond
- * timestamp at evaluation time. Wraps the shared `DatetimeLiteralSchema` with a
- * DataGrid-specific name. Supported formats:
- * - RFC 9557 with IANA timezone: `"2024-06-15T14:00:00[Europe/Stockholm]"` (offset
- *   inferred) 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"`
- * - Date-only (treated as UTC midnight): `"2024-01-01"`
- *
- * Unzoned datetimes without `Z` or an offset are treated as UTC wall-clock time.
- */
-export const DataGridDatetimeLiteralSchema = DatetimeLiteralSchema;
-/**
- * A plain (unzoned) ISO 8601 date or datetime literal that resolves to a Unix
- * millisecond timestamp in the browser's local timezone at evaluation time.
- * Wraps the shared `LocalDatetimeLiteralSchema` with a DataGrid-specific name.
- *
- * Only plain date/datetime strings without timezone qualifiers are accepted:
- * - Plain datetime: `"2024-01-01T14:30:00"`
- * - Date-only (treated as local midnight): `"2024-01-01"`
- *
- * Strings with `Z`, a UTC offset, or an IANA bracket are rejected — use
- * `{ datetime }` for timezone-aware instants.
- */
-export const DataGridLocalDatetimeLiteralSchema = LocalDatetimeLiteralSchema;
-/**
- * An ISO 8601 time literal that resolves to milliseconds since UTC midnight at
- * evaluation time. Wraps the shared `TimeLiteralSchema` with a DataGrid-specific
- * name. Supported formats:
- * - Local time (treated as UTC): `"14:30:00"`, `"14:30:00.500"`
- * - Offset time (UTC-normalised): `"14:30:00+02:00"`
- */
-export const DataGridTimeLiteralSchema = TimeLiteralSchema;
-/** An operand in a style-rule where clause -- either a literal value or a column reference. */
-export const DataGridStyleRuleOperandSchema = z.union([
-    DataGridColumnRefSchema,
-    DataGridStyleRuleLiteralSchema,
-]);
-export const DataGridStyleRuleWhereSchema = z.lazy(() => z.union([
-    z.object({ not: DataGridStyleRuleWhereSchema }),
-    z.object({ and: z.array(DataGridStyleRuleWhereSchema) }),
-    z.object({ or: z.array(DataGridStyleRuleWhereSchema) }),
-    z.object({
-        equal: z.tuple([
-            DataGridStyleRuleOperandSchema,
-            DataGridStyleRuleOperandSchema,
-        ]),
-    }),
-    z.object({
-        lessThan: z.tuple([
-            DataGridStyleRuleOperandSchema,
-            DataGridStyleRuleOperandSchema,
-        ]),
-    }),
-    z.object({
-        lessThanOrEqual: z.tuple([
-            DataGridStyleRuleOperandSchema,
-            DataGridStyleRuleOperandSchema,
-        ]),
-    }),
-    z.object({
-        greaterThan: z.tuple([
-            DataGridStyleRuleOperandSchema,
-            DataGridStyleRuleOperandSchema,
-        ]),
-    }),
-    z.object({
-        greaterThanOrEqual: z.tuple([
-            DataGridStyleRuleOperandSchema,
-            DataGridStyleRuleOperandSchema,
-        ]),
-    }),
-    z.object({
-        contains: z.tuple([
-            DataGridStyleRuleOperandSchema,
-            DataGridStyleRuleOperandSchema,
-        ]),
-    }),
-    z.object({
-        startsWith: z.tuple([
-            DataGridStyleRuleOperandSchema,
-            DataGridStyleRuleOperandSchema,
-        ]),
-    }),
-    z.object({
-        endsWith: z.tuple([
-            DataGridStyleRuleOperandSchema,
-            DataGridStyleRuleOperandSchema,
-        ]),
-    }),
-    z.object({ isNull: DataGridStyleRuleOperandSchema }),
-]));
-/**
- * Gradient coloring based on a continuous orderable column value.
- * Colors should be hex strings (#rrggbb).
- * Temporal range boundaries resolve to numbers before interpolation.
- * If the column value is missing or non-orderable, the colorRange is ignored.
- */
-export const DataGridColorRangeSchema = z.object({
-    /** Disable this color range without removing it. */
-    isDisabled: z.boolean().optional(),
-    /** Hex color (#rrggbb) at the maximum value. */
-    maxColor: z.string(),
-    /** The high end of the range. Values above this clamp to maxColor. */
-    maxValue: DataGridRangeLiteralSchema,
-    /** Hex color (#rrggbb) at the optional mid-point for a 3-stop gradient. */
-    midColor: z.string().optional(),
-    /** Optional inflection point between minValue and maxValue for a 3-stop gradient. */
-    midValue: DataGridRangeLiteralSchema.optional(),
-    /** Hex color (#rrggbb) at the minimum value. */
-    minColor: z.string(),
-    /** The low end of the range. Values below this clamp to minColor. */
-    minValue: DataGridRangeLiteralSchema,
-    /** The column whose orderable value drives the interpolation. */
-    onColumn: z.string(),
-});
-/** A disable-able static color value. */
-export const DataGridDisableableColorSchema = z.object({
-    /** Disable this style without removing it. */
-    isDisabled: z.boolean().optional(),
-    /** The CSS color value (e.g. '#fee2e2'). */
-    value: z.string(),
-});
-/** Visual properties that a style rule can apply to a cell or row. */
-export const DataGridCellStyleSchema = z.object({
-    /** CSS background color / cell fill (e.g. '#fee2e2'). Matches the graph `Style.color`. */
-    color: DataGridDisableableColorSchema.optional(),
-    /** Gradient color interpolation applied to the cell fill. Matches the graph `Style.colorRange`. */
-    colorRange: DataGridColorRangeSchema.optional(),
-    /** CSS text color (e.g. '#991b1b'). Grid-only; no graph equivalent. */
-    textColor: DataGridDisableableColorSchema.optional(),
-    /** Gradient color interpolation applied to the text color. Grid-only; no graph equivalent. */
-    textColorRange: DataGridColorRangeSchema.optional(),
-});
-/**
- * metaData is an free-form object that can be used to store additional information about a style rule.
- * The data is not taken into account when evaluating the rule.
- */
-const metaDataSchema = z.record(z.string(), z.unknown());
-/** A single declarative rule that conditionally applies styles to DataGrid cells. */
-export const DataGridStyleRuleSchema = z.object({
-    /** Style properties to apply when the rule matches. */
-    apply: DataGridCellStyleSchema,
-    /** Which column this rule targets. Set to null to apply styles to all columns (row-level effect). */
-    column: z.string().nullable(),
-    /** Disable this rule without removing it. */
-    isDisabled: z.boolean().optional(),
-    /** Additional metadata about the rule. */
-    metaData: metaDataSchema.optional(),
-    /** Higher priority rules are applied later (override lower). Must be `>= 0`; negative values are reserved for internal use. Rules without explicit priority preserve their array order but are always applied before rules with explicit priority. */
-    priority: z.number().nonnegative().optional(),
-    /** Condition to evaluate. If omitted, rule always applies to matched column(s). */
-    where: DataGridStyleRuleWhereSchema.optional(),
-});
-/**
- * Runtime type guard for {@link DataGridStyleRule}, backed by the internal Zod
- * schema. Narrows an `unknown` value to `DataGridStyleRule` when it is a valid
- * style rule.
- *
- * This lets consumers validate values without taking a dependency on Zod or on
- * our schema export. For example, it can be passed to another validation
- * library's custom check:
- *
- * @example
- * ```ts
- * import { z } from 'zod';
- * import { isDataGridStyleRule, type DataGridStyleRule } from '@neo4j-ndl/react';
- *
- * const formSchema = z.object({
- *   rule: z.custom<DataGridStyleRule>(isDataGridStyleRule),
- *   notes: z.string(),
- * });
- * ```
- */
-export const isDataGridStyleRule = (value) => DataGridStyleRuleSchema.safeParse(value).success;
+export {};
 //# sourceMappingURL=types.js.map

package/lib/esm/data-grid/style-rules/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/data-grid/style-rules/types.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\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 {\n  BigintLiteralSchema,\n  DatetimeLiteralSchema,\n  LocalDatetimeLiteralSchema,\n  NumericLiteralSchema,\n  RangeLiteralSchema,\n  TimeLiteralSchema,\n} from '../../_generated/style-rules';\n\n/*\n * Style types defined in Zod, so that we can use the schemas to generate JSON Schema.\n * This is useful for generating documentation, importing and for future integration into editors.\n */\n\n/**\n * A literal value used in style-rule where clauses, converter return values,\n * and cell data. Temporal wrappers resolve to numbers at evaluation time.\n */\nexport const DataGridStyleRuleLiteralSchema = z.union([\n  z.string(),\n  NumericLiteralSchema,\n  z.boolean(),\n  z.null(),\n  DatetimeLiteralSchema,\n  LocalDatetimeLiteralSchema,\n  TimeLiteralSchema,\n]);\nexport type DataGridStyleRuleLiteral = z.infer<\n  typeof DataGridStyleRuleLiteralSchema\n>;\n\n/** A JSON-safe bigint literal represented by a signed decimal string. */\nexport const DataGridBigintLiteralSchema = BigintLiteralSchema;\nexport type DataGridBigintLiteral = z.infer<typeof DataGridBigintLiteralSchema>;\n\n/** A number, native bigint, or JSON-safe bigint literal. */\nexport const DataGridNumericLiteralSchema = NumericLiteralSchema;\nexport type DataGridNumericLiteral = z.infer<\n  typeof DataGridNumericLiteralSchema\n>;\n\n/** A numeric, datetime, localdatetime, or time literal used as a range boundary. */\nexport const DataGridRangeLiteralSchema = RangeLiteralSchema;\nexport type DataGridRangeLiteral = z.infer<typeof DataGridRangeLiteralSchema>;\n\n/** A reference to a column whose cell value is resolved at evaluation time. */\nexport const DataGridColumnRefSchema = z.object({ column: z.string() });\nexport type DataGridColumnRef = z.infer<typeof DataGridColumnRefSchema>;\n\n/**\n * An ISO 8601 or RFC 9557 datetime literal that resolves to a Unix millisecond\n * timestamp at evaluation time. Wraps the shared `DatetimeLiteralSchema` with a\n * DataGrid-specific name. Supported formats:\n * - RFC 9557 with IANA timezone: `\"2024-06-15T14:00:00[Europe/Stockholm]\"` (offset\n *   inferred) or `\"2024-06-15T14:00:00+02:00[Europe/Stockholm]\"` (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\"`\n * - Date-only (treated as UTC midnight): `\"2024-01-01\"`\n *\n * Unzoned datetimes without `Z` or an offset are treated as UTC wall-clock time.\n */\nexport const DataGridDatetimeLiteralSchema = DatetimeLiteralSchema;\nexport type DataGridDatetimeLiteral = z.infer<\n  typeof DataGridDatetimeLiteralSchema\n>;\n\n/**\n * A plain (unzoned) ISO 8601 date or datetime literal that resolves to a Unix\n * millisecond timestamp in the browser's local timezone at evaluation time.\n * Wraps the shared `LocalDatetimeLiteralSchema` with a DataGrid-specific name.\n *\n * Only plain date/datetime strings without timezone qualifiers are accepted:\n * - Plain datetime: `\"2024-01-01T14:30:00\"`\n * - Date-only (treated as local midnight): `\"2024-01-01\"`\n *\n * Strings with `Z`, a UTC offset, or an IANA bracket are rejected — use\n * `{ datetime }` for timezone-aware instants.\n */\nexport const DataGridLocalDatetimeLiteralSchema = LocalDatetimeLiteralSchema;\nexport type DataGridLocalDatetimeLiteral = z.infer<\n  typeof DataGridLocalDatetimeLiteralSchema\n>;\n\n/**\n * An ISO 8601 time literal that resolves to milliseconds since UTC midnight at\n * evaluation time. Wraps the shared `TimeLiteralSchema` with a DataGrid-specific\n * name. Supported formats:\n * - Local time (treated as UTC): `\"14:30:00\"`, `\"14:30:00.500\"`\n * - Offset time (UTC-normalised): `\"14:30:00+02:00\"`\n */\nexport const DataGridTimeLiteralSchema = TimeLiteralSchema;\nexport type DataGridTimeLiteral = z.infer<typeof DataGridTimeLiteralSchema>;\n\n/** An operand in a style-rule where clause -- either a literal value or a column reference. */\nexport const DataGridStyleRuleOperandSchema = z.union([\n  DataGridColumnRefSchema,\n  DataGridStyleRuleLiteralSchema,\n]);\nexport type DataGridStyleRuleOperand = z.infer<\n  typeof DataGridStyleRuleOperandSchema\n>;\n\n/**\n * Recursive WHERE clause for conditional expressions.\n * Inspired by the graph visualization style rule system but adapted for tabular data.\n *\n * The type is manually defined for the export, since zod doesn't support\n * exporting inferred recursive types.\n */\nexport type DataGridStyleRuleWhere =\n  | { not: DataGridStyleRuleWhere }\n  | { and: DataGridStyleRuleWhere[] }\n  | { or: DataGridStyleRuleWhere[] }\n  | { equal: [DataGridStyleRuleOperand, DataGridStyleRuleOperand] }\n  | { lessThan: [DataGridStyleRuleOperand, DataGridStyleRuleOperand] }\n  | { lessThanOrEqual: [DataGridStyleRuleOperand, DataGridStyleRuleOperand] }\n  | { greaterThan: [DataGridStyleRuleOperand, DataGridStyleRuleOperand] }\n  | { greaterThanOrEqual: [DataGridStyleRuleOperand, DataGridStyleRuleOperand] }\n  | { contains: [DataGridStyleRuleOperand, DataGridStyleRuleOperand] }\n  | { startsWith: [DataGridStyleRuleOperand, DataGridStyleRuleOperand] }\n  | { endsWith: [DataGridStyleRuleOperand, DataGridStyleRuleOperand] }\n  | { isNull: DataGridStyleRuleOperand };\n\nexport const DataGridStyleRuleWhereSchema: z.ZodType<DataGridStyleRuleWhere> =\n  z.lazy(() =>\n    z.union([\n      z.object({ not: DataGridStyleRuleWhereSchema }),\n      z.object({ and: z.array(DataGridStyleRuleWhereSchema) }),\n      z.object({ or: z.array(DataGridStyleRuleWhereSchema) }),\n      z.object({\n        equal: z.tuple([\n          DataGridStyleRuleOperandSchema,\n          DataGridStyleRuleOperandSchema,\n        ]),\n      }),\n      z.object({\n        lessThan: z.tuple([\n          DataGridStyleRuleOperandSchema,\n          DataGridStyleRuleOperandSchema,\n        ]),\n      }),\n      z.object({\n        lessThanOrEqual: z.tuple([\n          DataGridStyleRuleOperandSchema,\n          DataGridStyleRuleOperandSchema,\n        ]),\n      }),\n      z.object({\n        greaterThan: z.tuple([\n          DataGridStyleRuleOperandSchema,\n          DataGridStyleRuleOperandSchema,\n        ]),\n      }),\n      z.object({\n        greaterThanOrEqual: z.tuple([\n          DataGridStyleRuleOperandSchema,\n          DataGridStyleRuleOperandSchema,\n        ]),\n      }),\n      z.object({\n        contains: z.tuple([\n          DataGridStyleRuleOperandSchema,\n          DataGridStyleRuleOperandSchema,\n        ]),\n      }),\n      z.object({\n        startsWith: z.tuple([\n          DataGridStyleRuleOperandSchema,\n          DataGridStyleRuleOperandSchema,\n        ]),\n      }),\n      z.object({\n        endsWith: z.tuple([\n          DataGridStyleRuleOperandSchema,\n          DataGridStyleRuleOperandSchema,\n        ]),\n      }),\n      z.object({ isNull: DataGridStyleRuleOperandSchema }),\n    ]),\n  );\n\n/**\n * Gradient coloring based on a continuous orderable column value.\n * Colors should be hex strings (#rrggbb).\n * Temporal range boundaries resolve to numbers before interpolation.\n * If the column value is missing or non-orderable, the colorRange is ignored.\n */\nexport const DataGridColorRangeSchema = z.object({\n  /** Disable this color range without removing it. */\n  isDisabled: z.boolean().optional(),\n  /** Hex color (#rrggbb) at the maximum value. */\n  maxColor: z.string(),\n  /** The high end of the range. Values above this clamp to maxColor. */\n  maxValue: DataGridRangeLiteralSchema,\n  /** Hex color (#rrggbb) at the optional mid-point for a 3-stop gradient. */\n  midColor: z.string().optional(),\n  /** Optional inflection point between minValue and maxValue for a 3-stop gradient. */\n  midValue: DataGridRangeLiteralSchema.optional(),\n  /** Hex color (#rrggbb) at the minimum value. */\n  minColor: z.string(),\n  /** The low end of the range. Values below this clamp to minColor. */\n  minValue: DataGridRangeLiteralSchema,\n  /** The column whose orderable value drives the interpolation. */\n  onColumn: z.string(),\n});\nexport type DataGridColorRange = z.infer<typeof DataGridColorRangeSchema>;\n\n/** A disable-able static color value. */\nexport const DataGridDisableableColorSchema = z.object({\n  /** Disable this style without removing it. */\n  isDisabled: z.boolean().optional(),\n  /** The CSS color value (e.g. '#fee2e2'). */\n  value: z.string(),\n});\nexport type DataGridDisableableColor = z.infer<\n  typeof DataGridDisableableColorSchema\n>;\n\n/** Visual properties that a style rule can apply to a cell or row. */\nexport const DataGridCellStyleSchema = z.object({\n  /** CSS background color / cell fill (e.g. '#fee2e2'). Matches the graph `Style.color`. */\n  color: DataGridDisableableColorSchema.optional(),\n  /** Gradient color interpolation applied to the cell fill. Matches the graph `Style.colorRange`. */\n  colorRange: DataGridColorRangeSchema.optional(),\n  /** CSS text color (e.g. '#991b1b'). Grid-only; no graph equivalent. */\n  textColor: DataGridDisableableColorSchema.optional(),\n  /** Gradient color interpolation applied to the text color. Grid-only; no graph equivalent. */\n  textColorRange: DataGridColorRangeSchema.optional(),\n});\nexport type DataGridCellStyle = z.infer<typeof DataGridCellStyleSchema>;\n\n/**\n * metaData is an free-form object that can be used to store additional information about a style rule.\n * The data is not taken into account when evaluating the rule.\n */\nconst metaDataSchema = z.record(z.string(), z.unknown());\n\n/**\n * A function that converts a complex or non-scalar cell value into a\n * `DataGridStyleRuleLiteral` so it can participate in where-clause evaluation\n * and color-range interpolation.\n *\n * The function receives the raw cell value (`unknown`) and must return a scalar\n * (`string | number | bigint | { bigint: string } | boolean | null`) or a\n * temporal wrapper (`{ datetime: string }`, `{ localdatetime: string }`,\n * `{ time: string }`). The engine parses temporal wrappers to milliseconds.\n * Return `null` or `undefined` to signal that the value is missing or cannot\n * be represented.\n *\n * Note: converter functions are TypeScript-only — they cannot be serialized as\n * JSON, so no Zod schema is provided.\n */\nexport type DataGridStyleRuleValueConverter = (\n  value: unknown,\n) => DataGridStyleRuleLiteral | undefined;\n\n/**\n * A map of column id → converter function.\n * Pass this as the `styleRuleValueConverters` prop on `DataGrid` to teach the\n * style-rule engine how to interpret complex cell values for specific columns.\n *\n * @example\n * ```ts\n * const converters: DataGridStyleRuleValueConverters = {\n *   priority: (v) => {\n *     const s = v as { min: number; max: number };\n *     return s.max - s.min;\n *   },\n * };\n * ```\n */\nexport type DataGridStyleRuleValueConverters = Record<\n  string,\n  DataGridStyleRuleValueConverter\n>;\n\n/** A single declarative rule that conditionally applies styles to DataGrid cells. */\nexport const DataGridStyleRuleSchema = z.object({\n  /** Style properties to apply when the rule matches. */\n  apply: DataGridCellStyleSchema,\n  /** Which column this rule targets. Set to null to apply styles to all columns (row-level effect). */\n  column: z.string().nullable(),\n  /** Disable this rule without removing it. */\n  isDisabled: z.boolean().optional(),\n  /** Additional metadata about the rule. */\n  metaData: metaDataSchema.optional(),\n  /** Higher priority rules are applied later (override lower). Must be `>= 0`; negative values are reserved for internal use. Rules without explicit priority preserve their array order but are always applied before rules with explicit priority. */\n  priority: z.number().nonnegative().optional(),\n  /** Condition to evaluate. If omitted, rule always applies to matched column(s). */\n  where: DataGridStyleRuleWhereSchema.optional(),\n});\nexport type DataGridStyleRule = z.infer<typeof DataGridStyleRuleSchema>;\n\n/**\n * Runtime type guard for {@link DataGridStyleRule}, backed by the internal Zod\n * schema. Narrows an `unknown` value to `DataGridStyleRule` when it is a valid\n * style rule.\n *\n * This lets consumers validate values without taking a dependency on Zod or on\n * our schema export. For example, it can be passed to another validation\n * library's custom check:\n *\n * @example\n * ```ts\n * import { z } from 'zod';\n * import { isDataGridStyleRule, type DataGridStyleRule } from '@neo4j-ndl/react';\n *\n * const formSchema = z.object({\n *   rule: z.custom<DataGridStyleRule>(isDataGridStyleRule),\n *   notes: z.string(),\n * });\n * ```\n */\nexport const isDataGridStyleRule = (\n  value: unknown,\n): value is DataGridStyleRule =>\n  DataGridStyleRuleSchema.safeParse(value).success;\n"]}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/data-grid/style-rules/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG","sourcesContent":["/*!\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 {\n  BigintLiteral,\n  DatetimeLiteral,\n  LocalDatetimeLiteral,\n  NumericLiteral,\n  RangeLiteral,\n  TimeLiteral,\n} from '../../_generated/style-rules';\n\n/*\n * These style types are hand-written so that Zod stays out of the published\n * type declarations. The schemas that validate them at runtime live in\n * `./internal/schemas`, which is deliberately not re-exported; each schema is\n * anchored to its type there with `satisfies`, so the two cannot drift.\n */\n\n/**\n * A literal value used in style-rule where clauses, converter return values,\n * and cell data. Temporal wrappers resolve to numbers at evaluation time.\n */\nexport type DataGridStyleRuleLiteral =\n  | string\n  | NumericLiteral\n  | boolean\n  | null\n  | DatetimeLiteral\n  | LocalDatetimeLiteral\n  | TimeLiteral;\n\n/** A JSON-safe bigint literal represented by a signed decimal string. */\nexport type DataGridBigintLiteral = BigintLiteral;\n\n/** A number, native bigint, or JSON-safe bigint literal. */\nexport type DataGridNumericLiteral = NumericLiteral;\n\n/** A numeric, datetime, localdatetime, or time literal used as a range boundary. */\nexport type DataGridRangeLiteral = RangeLiteral;\n\n/** A reference to a column whose cell value is resolved at evaluation time. */\nexport type DataGridColumnRef = { column: string };\n\n/**\n * An ISO 8601 or RFC 9557 datetime literal that resolves to a Unix millisecond\n * timestamp at evaluation time. Wraps the shared `DatetimeLiteralSchema` with a\n * DataGrid-specific name. Supported formats:\n * - RFC 9557 with IANA timezone: `\"2024-06-15T14:00:00[Europe/Stockholm]\"` (offset\n *   inferred) or `\"2024-06-15T14:00:00+02:00[Europe/Stockholm]\"` (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\"`\n * - Date-only (treated as UTC midnight): `\"2024-01-01\"`\n *\n * Unzoned datetimes without `Z` or an offset are treated as UTC wall-clock time.\n */\nexport type DataGridDatetimeLiteral = DatetimeLiteral;\n\n/**\n * A plain (unzoned) ISO 8601 date or datetime literal that resolves to a Unix\n * millisecond timestamp in the browser's local timezone at evaluation time.\n * Wraps the shared `LocalDatetimeLiteralSchema` with a DataGrid-specific name.\n *\n * Only plain date/datetime strings without timezone qualifiers are accepted:\n * - Plain datetime: `\"2024-01-01T14:30:00\"`\n * - Date-only (treated as local midnight): `\"2024-01-01\"`\n *\n * Strings with `Z`, a UTC offset, or an IANA bracket are rejected — use\n * `{ datetime }` for timezone-aware instants.\n */\nexport type DataGridLocalDatetimeLiteral = LocalDatetimeLiteral;\n\n/**\n * An ISO 8601 time literal that resolves to milliseconds since UTC midnight at\n * evaluation time. Wraps the shared `TimeLiteralSchema` with a DataGrid-specific\n * name. Supported formats:\n * - Local time (treated as UTC): `\"14:30:00\"`, `\"14:30:00.500\"`\n * - Offset time (UTC-normalised): `\"14:30:00+02:00\"`\n */\nexport type DataGridTimeLiteral = TimeLiteral;\n\n/** An operand in a style-rule where clause -- either a literal value or a column reference. */\nexport type DataGridStyleRuleOperand =\n  | DataGridColumnRef\n  | DataGridStyleRuleLiteral;\n\n/**\n * Recursive WHERE clause for conditional expressions.\n * Inspired by the graph visualization style rule system but adapted for tabular data.\n *\n * The type is manually defined for the export, since zod doesn't support\n * exporting inferred recursive types.\n */\nexport type DataGridStyleRuleWhere =\n  | { not: DataGridStyleRuleWhere }\n  | { and: DataGridStyleRuleWhere[] }\n  | { or: DataGridStyleRuleWhere[] }\n  | { equal: [DataGridStyleRuleOperand, DataGridStyleRuleOperand] }\n  | { lessThan: [DataGridStyleRuleOperand, DataGridStyleRuleOperand] }\n  | { lessThanOrEqual: [DataGridStyleRuleOperand, DataGridStyleRuleOperand] }\n  | { greaterThan: [DataGridStyleRuleOperand, DataGridStyleRuleOperand] }\n  | { greaterThanOrEqual: [DataGridStyleRuleOperand, DataGridStyleRuleOperand] }\n  | { contains: [DataGridStyleRuleOperand, DataGridStyleRuleOperand] }\n  | { startsWith: [DataGridStyleRuleOperand, DataGridStyleRuleOperand] }\n  | { endsWith: [DataGridStyleRuleOperand, DataGridStyleRuleOperand] }\n  | { isNull: DataGridStyleRuleOperand };\n\n/**\n * Gradient coloring based on a continuous orderable column value.\n * Colors should be hex strings (#rrggbb).\n * Temporal range boundaries resolve to numbers before interpolation.\n * If the column value is missing or non-orderable, the colorRange is ignored.\n */\nexport type DataGridColorRange = {\n  /** Disable this color range without removing it. */\n  isDisabled?: boolean | undefined;\n  /** Hex color (#rrggbb) at the maximum value. */\n  maxColor: string;\n  /** The high end of the range. Values above this clamp to maxColor. */\n  maxValue: DataGridRangeLiteral;\n  /** Hex color (#rrggbb) at the optional mid-point for a 3-stop gradient. */\n  midColor?: string | undefined;\n  /** Optional inflection point between minValue and maxValue for a 3-stop gradient. */\n  midValue?: DataGridRangeLiteral | undefined;\n  /** Hex color (#rrggbb) at the minimum value. */\n  minColor: string;\n  /** The low end of the range. Values below this clamp to minColor. */\n  minValue: DataGridRangeLiteral;\n  /** The column whose orderable value drives the interpolation. */\n  onColumn: string;\n};\n\n/** A disable-able static color value. */\nexport type DataGridDisableableColor = {\n  /** Disable this style without removing it. */\n  isDisabled?: boolean | undefined;\n  /** The CSS color value (e.g. '#fee2e2'). */\n  value: string;\n};\n\n/** Visual properties that a style rule can apply to a cell or row. */\nexport type DataGridCellStyle = {\n  /** CSS background color / cell fill (e.g. '#fee2e2'). Matches the graph `Style.color`. */\n  color?: DataGridDisableableColor | undefined;\n  /** Gradient color interpolation applied to the cell fill. Matches the graph `Style.colorRange`. */\n  colorRange?: DataGridColorRange | undefined;\n  /** CSS text color (e.g. '#991b1b'). Grid-only; no graph equivalent. */\n  textColor?: DataGridDisableableColor | undefined;\n  /** Gradient color interpolation applied to the text color. Grid-only; no graph equivalent. */\n  textColorRange?: DataGridColorRange | undefined;\n};\n\n/**\n * A function that converts a complex or non-scalar cell value into a\n * `DataGridStyleRuleLiteral` so it can participate in where-clause evaluation\n * and color-range interpolation.\n *\n * The function receives the raw cell value (`unknown`) and must return a scalar\n * (`string | number | bigint | { bigint: string } | boolean | null`) or a\n * temporal wrapper (`{ datetime: string }`, `{ localdatetime: string }`,\n * `{ time: string }`). The engine parses temporal wrappers to milliseconds.\n * Return `null` or `undefined` to signal that the value is missing or cannot\n * be represented.\n *\n * Note: converter functions are TypeScript-only — they cannot be serialized as\n * JSON, so no Zod schema is provided.\n */\nexport type DataGridStyleRuleValueConverter = (\n  value: unknown,\n) => DataGridStyleRuleLiteral | undefined;\n\n/**\n * A map of column id → converter function.\n * Pass this as the `styleRuleValueConverters` prop on `DataGrid` to teach the\n * style-rule engine how to interpret complex cell values for specific columns.\n *\n * @example\n * ```ts\n * const converters: DataGridStyleRuleValueConverters = {\n *   priority: (v) => {\n *     const s = v as { min: number; max: number };\n *     return s.max - s.min;\n *   },\n * };\n * ```\n */\nexport type DataGridStyleRuleValueConverters = Record<\n  string,\n  DataGridStyleRuleValueConverter\n>;\n\n/** A single declarative rule that conditionally applies styles to DataGrid cells. */\nexport type DataGridStyleRule = {\n  /** Style properties to apply when the rule matches. */\n  apply: DataGridCellStyle;\n  /** Which column this rule targets. Set to null to apply styles to all columns (row-level effect). */\n  column: string | null;\n  /** Disable this rule without removing it. */\n  isDisabled?: boolean | undefined;\n  /** Additional metadata about the rule. */\n  metaData?: Record<string, unknown> | undefined;\n  /** Higher priority rules are applied later (override lower). Must be `>= 0`; negative values are reserved for internal use. Rules without explicit priority preserve their array order but are always applied before rules with explicit priority. */\n  priority?: number | undefined;\n  /** Condition to evaluate. If omitted, rule always applies to matched column(s). */\n  where?: DataGridStyleRuleWhere | undefined;\n};\n"]}

package/lib/esm/date-picker/DatePicker.js

@@ -10,8 +10,6 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-// TODO: try to fix as some point
-/* eslint-disable @typescript-eslint/naming-convention */
 /*!
  *
  *  Copyright (c) "Neo4j"
@@ -84,18 +82,22 @@ export const DatePicker = (_a) => {
         setPicker(picker === action ? 'day' : action);
     }, [picker]);
     const CustomHeader = useCallback((props) => {
-        const { decreaseMonth, increaseMonth, increaseYear, decreaseYear, nextMonthButtonDisabled, nextYearButtonDisabled, prevMonthButtonDisabled, prevYearButtonDisabled, } = props;
+        const { decreaseMonth, increaseMonth, increaseYear, decreaseYear, nextMonthButtonDisabled: isNextMonthButtonDisabled, nextYearButtonDisabled: isNextYearButtonDisabled, prevMonthButtonDisabled: isPrevMonthButtonDisabled, prevYearButtonDisabled: isPrevYearButtonDisabled, } = props;
         const prevCallback = picker === 'year' ? decreaseYear : decreaseMonth;
         const nextCallback = picker === 'year' ? increaseYear : increaseMonth;
-        const prevDisabled = picker === 'year' ? prevYearButtonDisabled : prevMonthButtonDisabled;
-        const nextDisabled = picker === 'year' ? nextYearButtonDisabled : nextMonthButtonDisabled;
+        const isPrevDisabled = picker === 'year'
+            ? isPrevYearButtonDisabled
+            : isPrevMonthButtonDisabled;
+        const isNextDisabled = picker === 'year'
+            ? isNextYearButtonDisabled
+            : isNextMonthButtonDisabled;
         return (_jsxs("div", { className: "ndl-datepicker-header", children: [_jsxs("div", { className: "ndl-datepicker-selects", children: [picker !== 'year' && (_jsx("button", { type: "button", "aria-label": `${picker === 'month' ? 'Close' : 'Open'} month picker`, "aria-pressed": picker === 'month', onClick: () => headerAction('month'), children: _jsxs("div", { className: "ndl-datepicker-select-content", children: [_jsx(Typography, { variant: "subheading-small", children: format(props.date, 'MMM') }), _jsx(ChevronDownIconOutline, { className: classNames('ndl-datepicker-chevron', {
                                             'ndl-open': picker === 'month',
                                         }), "aria-label": "Chevron icon" })] }) })), picker !== 'month' && (_jsx("button", { type: "button", "aria-label": `${picker === 'year' ? 'Close' : 'Open'} year picker`, onClick: () => headerAction('year'), children: _jsxs("div", { className: "ndl-datepicker-select-content", children: [_jsx(Typography, { variant: "subheading-small", children: picker === 'year'
                                             ? getYearsPeriodString(props.date, reactDatePickerProps === null || reactDatePickerProps === void 0 ? void 0 : reactDatePickerProps.yearItemNumber)
                                             : format(props.date, 'yyyy') }), _jsx(ChevronDownIconOutline, { className: classNames('ndl-datepicker-chevron', {
                                             'ndl-open': picker === 'year',
-                                        }), "aria-label": "Chevron icon" })] }) }))] }), picker !== 'month' && (_jsxs("div", { className: "ndl-datepicker-nav", children: [_jsx(CleanIconButton, { description: picker === 'year' ? 'Previous period' : 'Previous month', onClick: prevCallback, isDisabled: prevDisabled, size: "small", children: _jsx(ArrowLeftIconOutline, {}) }), _jsx(CleanIconButton, { description: picker === 'year' ? 'Next period' : 'Next month', onClick: nextCallback, isDisabled: nextDisabled, size: "small", children: _jsx(ArrowRightIconOutline, {}) })] }))] }));
+                                        }), "aria-label": "Chevron icon" })] }) }))] }), picker !== 'month' && (_jsxs("div", { className: "ndl-datepicker-nav", children: [_jsx(CleanIconButton, { description: picker === 'year' ? 'Previous period' : 'Previous month', onClick: prevCallback, isDisabled: isPrevDisabled, size: "small", children: _jsx(ArrowLeftIconOutline, {}) }), _jsx(CleanIconButton, { description: picker === 'year' ? 'Next period' : 'Next month', onClick: nextCallback, isDisabled: isNextDisabled, size: "small", children: _jsx(ArrowRightIconOutline, {}) })] }))] }));
     }, [picker, headerAction, reactDatePickerProps === null || reactDatePickerProps === void 0 ? void 0 : reactDatePickerProps.yearItemNumber]);
     const handleTimeChange = (newTime) => {
         if (reactDatePickerProps.selectsRange ||