@neo4j-ndl/react-graph 1.2.22 → 1.2.24

package/lib/cjs/styling/style-types.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ *
+ *  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/>.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StyleRuleSchema = exports.StyleSchema = exports.NvlCaptionSchema = exports.CaptionVariationSchema = exports.CaptionValueSchema = exports.WhereSchema = exports.ValueSchema = exports.CypherValueSchema = exports.MatchSchema = exports.SelectorSchema = void 0;
+const zod_1 = require("zod");
+/*
+ * 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.
+ *
+ * Some simple examples of rules:
+ * - Match all nodes with label "Person" and apply red color
+ *  { match: { label: "Person" }, apply: { color: "red" } }
+ *
+ * - Match all relationships with type "KNOWS" which have the property "name" equal to "John" and apply width 10
+ *  { match: { reltype: "KNOWS" }, where: { equal: [{ property: "name" }, "John"] }, apply: { width: 10 } }
+ */
+// Selector schemas. This is what can go under the `match` key.
+const LabelSelectorSchema = zod_1.z.object({
+    label: zod_1.z.string().nullable(),
+});
+const ReltypeSelectorSchema = zod_1.z.object({
+    reltype: zod_1.z.string().nullable(),
+});
+const PropertySelectorSchema = zod_1.z.object({
+    property: zod_1.z.string(),
+});
+exports.SelectorSchema = zod_1.z.union([
+    LabelSelectorSchema,
+    ReltypeSelectorSchema,
+    PropertySelectorSchema,
+]);
+exports.MatchSchema = zod_1.z.union([
+    LabelSelectorSchema,
+    ReltypeSelectorSchema,
+    PropertySelectorSchema,
+]);
+// Schemas for the values that can go under the `where` key. Starts with defining the literal values.
+exports.CypherValueSchema = zod_1.z.union([
+    zod_1.z.string(),
+    zod_1.z.number(),
+    zod_1.z.boolean(),
+    zod_1.z.null(),
+]);
+exports.ValueSchema = zod_1.z
+    .union([exports.SelectorSchema, exports.CypherValueSchema])
+    .describe('Either a property/label/reltype selector (e.g., {property: "name"}) or a literal value (string, number, boolean, null).');
+exports.WhereSchema = zod_1.z.lazy(() => zod_1.z.union([
+    exports.SelectorSchema,
+    zod_1.z.object({ not: exports.WhereSchema }),
+    zod_1.z.object({ and: zod_1.z.array(exports.WhereSchema) }),
+    zod_1.z.object({ or: zod_1.z.array(exports.WhereSchema) }),
+    zod_1.z.object({ equal: zod_1.z.tuple([exports.ValueSchema, exports.ValueSchema]) }),
+    zod_1.z.object({ lessThan: zod_1.z.tuple([exports.ValueSchema, exports.ValueSchema]) }),
+    zod_1.z.object({ lessThanOrEqual: zod_1.z.tuple([exports.ValueSchema, exports.ValueSchema]) }),
+    zod_1.z.object({ greaterThan: zod_1.z.tuple([exports.ValueSchema, exports.ValueSchema]) }),
+    zod_1.z.object({ greaterThanOrEqual: zod_1.z.tuple([exports.ValueSchema, exports.ValueSchema]) }),
+    zod_1.z.object({ contains: zod_1.z.tuple([exports.ValueSchema, exports.ValueSchema]) }),
+    zod_1.z.object({ startsWith: zod_1.z.tuple([exports.ValueSchema, exports.ValueSchema]) }),
+    zod_1.z.object({ endsWith: zod_1.z.tuple([exports.ValueSchema, exports.ValueSchema]) }),
+    zod_1.z.object({ isNull: exports.ValueSchema }),
+]));
+// Schemas that go under the `apply` key.
+exports.CaptionValueSchema = zod_1.z.union([
+    zod_1.z.string(),
+    zod_1.z.object({ property: zod_1.z.string() }),
+    zod_1.z.object({ useType: zod_1.z.literal(true) }),
+]);
+exports.CaptionVariationSchema = zod_1.z.enum(['bold', 'italic', 'underline']);
+exports.NvlCaptionSchema = zod_1.z.object({
+    styles: zod_1.z.array(zod_1.z.string()).optional(),
+    value: exports.CaptionValueSchema.optional(),
+    key: zod_1.z.string().optional(),
+});
+/**
+ * OverlayIcon from NVL - icon displayed on top of a graph element
+ * @see @neo4j-nvl/base Node.overlayIcon
+ */
+const NvlOverlayIconSchema = zod_1.z.object({
+    url: zod_1.z.string(),
+    position: zod_1.z.array(zod_1.z.number()).optional(),
+    size: zod_1.z.number().optional(),
+});
+exports.StyleSchema = zod_1.z.object({
+    captionAlign: zod_1.z.enum(['top', 'bottom', 'center']).optional(),
+    captionSize: zod_1.z.number().optional(),
+    captions: zod_1.z.array(exports.NvlCaptionSchema).optional(),
+    color: zod_1.z.string().optional(),
+    icon: zod_1.z.string().optional(),
+    overlayIcon: NvlOverlayIconSchema.optional(),
+    size: zod_1.z.number().optional(),
+    width: zod_1.z.number().optional(),
+});
+exports.StyleRuleSchema = zod_1.z.object({
+    match: exports.MatchSchema,
+    where: exports.WhereSchema.optional(),
+    apply: exports.StyleSchema,
+    disabled: zod_1.z.boolean().optional(),
+    priority: zod_1.z.number().optional(),
+});
+//# sourceMappingURL=style-types.js.map

package/lib/cjs/styling/style-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"style-types.js","sourceRoot":"","sources":["../../../src/styling/style-types.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;GAmBG;;;AAGH,6BAAwB;AAExB;;;;;;;;;;GAUG;AAEH,+DAA+D;AAC/D,MAAM,mBAAmB,GAAG,OAAC,CAAC,MAAM,CAAC;IACnC,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC7B,CAAC,CAAC;AAEH,MAAM,qBAAqB,GAAG,OAAC,CAAC,MAAM,CAAC;IACrC,OAAO,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC/B,CAAC,CAAC;AAEH,MAAM,sBAAsB,GAAG,OAAC,CAAC,MAAM,CAAC;IACtC,QAAQ,EAAE,OAAC,CAAC,MAAM,EAAE;CACrB,CAAC,CAAC;AAEU,QAAA,cAAc,GAAG,OAAC,CAAC,KAAK,CAAC;IACpC,mBAAmB;IACnB,qBAAqB;IACrB,sBAAsB;CACvB,CAAC,CAAC;AAGU,QAAA,WAAW,GAAG,OAAC,CAAC,KAAK,CAAC;IACjC,mBAAmB;IACnB,qBAAqB;IACrB,sBAAsB;CACvB,CAAC,CAAC;AAEH,qGAAqG;AACxF,QAAA,iBAAiB,GAAG,OAAC,CAAC,KAAK,CAAC;IACvC,OAAC,CAAC,MAAM,EAAE;IACV,OAAC,CAAC,MAAM,EAAE;IACV,OAAC,CAAC,OAAO,EAAE;IACX,OAAC,CAAC,IAAI,EAAE;CACT,CAAC,CAAC;AAGU,QAAA,WAAW,GAAG,OAAC;KACzB,KAAK,CAAC,CAAC,sBAAc,EAAE,yBAAiB,CAAC,CAAC;KAC1C,QAAQ,CACP,yHAAyH,CAC1H,CAAC;AA+BS,QAAA,WAAW,GAAqB,OAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CACvD,OAAC,CAAC,KAAK,CAAC;IACN,sBAAc;IACd,OAAC,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,mBAAW,EAAE,CAAC;IAC9B,OAAC,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,OAAC,CAAC,KAAK,CAAC,mBAAW,CAAC,EAAE,CAAC;IACvC,OAAC,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,OAAC,CAAC,KAAK,CAAC,mBAAW,CAAC,EAAE,CAAC;IACtC,OAAC,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,OAAC,CAAC,KAAK,CAAC,CAAC,mBAAW,EAAE,mBAAW,CAAC,CAAC,EAAE,CAAC;IACxD,OAAC,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,OAAC,CAAC,KAAK,CAAC,CAAC,mBAAW,EAAE,mBAAW,CAAC,CAAC,EAAE,CAAC;IAC3D,OAAC,CAAC,MAAM,CAAC,EAAE,eAAe,EAAE,OAAC,CAAC,KAAK,CAAC,CAAC,mBAAW,EAAE,mBAAW,CAAC,CAAC,EAAE,CAAC;IAClE,OAAC,CAAC,MAAM,CAAC,EAAE,WAAW,EAAE,OAAC,CAAC,KAAK,CAAC,CAAC,mBAAW,EAAE,mBAAW,CAAC,CAAC,EAAE,CAAC;IAC9D,OAAC,CAAC,MAAM,CAAC,EAAE,kBAAkB,EAAE,OAAC,CAAC,KAAK,CAAC,CAAC,mBAAW,EAAE,mBAAW,CAAC,CAAC,EAAE,CAAC;IACrE,OAAC,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,OAAC,CAAC,KAAK,CAAC,CAAC,mBAAW,EAAE,mBAAW,CAAC,CAAC,EAAE,CAAC;IAC3D,OAAC,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,OAAC,CAAC,KAAK,CAAC,CAAC,mBAAW,EAAE,mBAAW,CAAC,CAAC,EAAE,CAAC;IAC7D,OAAC,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,OAAC,CAAC,KAAK,CAAC,CAAC,mBAAW,EAAE,mBAAW,CAAC,CAAC,EAAE,CAAC;IAC3D,OAAC,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,mBAAW,EAAE,CAAC;CAClC,CAAC,CACH,CAAC;AAEF,yCAAyC;AAC5B,QAAA,kBAAkB,GAAG,OAAC,CAAC,KAAK,CAAC;IACxC,OAAC,CAAC,MAAM,EAAE;IACV,OAAC,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,OAAC,CAAC,MAAM,EAAE,EAAE,CAAC;IAClC,OAAC,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,OAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;CACvC,CAAC,CAAC;AAGU,QAAA,sBAAsB,GAAG,OAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC;AAGjE,QAAA,gBAAgB,GAAG,OAAC,CAAC,MAAM,CAAC;IACvC,MAAM,EAAE,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;IACtC,KAAK,EAAE,0BAAkB,CAAC,QAAQ,EAAE;IACpC,GAAG,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC3B,CAAC,CAAC;AAGH;;;GAGG;AACH,MAAM,oBAAoB,GAAG,OAAC,CAAC,MAAM,CAAC;IACpC,GAAG,EAAE,OAAC,CAAC,MAAM,EAAE;IACf,QAAQ,EAAE,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;IACxC,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC5B,CAAC,CAAC;AAEU,QAAA,WAAW,GAAG,OAAC,CAAC,MAAM,CAAC;IAClC,YAAY,EAAE,OAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,QAAQ,EAAE;IAC5D,WAAW,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAClC,QAAQ,EAAE,OAAC,CAAC,KAAK,CAAC,wBAAgB,CAAC,CAAC,QAAQ,EAAE;IAC9C,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC5B,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC3B,WAAW,EAAE,oBAAoB,CAAC,QAAQ,EAAE;IAC5C,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC3B,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC7B,CAAC,CAAC;AAGU,QAAA,eAAe,GAAG,OAAC,CAAC,MAAM,CAAC;IACtC,KAAK,EAAE,mBAAW;IAClB,KAAK,EAAE,mBAAW,CAAC,QAAQ,EAAE;IAC7B,KAAK,EAAE,mBAAW;IAClB,QAAQ,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IAChC,QAAQ,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAChC,CAAC,CAAC","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 Node, type Relationship } from '@neo4j-nvl/base';\nimport { z } from 'zod';\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 * Some simple examples of rules:\n * - Match all nodes with label \"Person\" and apply red color\n *  { match: { label: \"Person\" }, apply: { color: \"red\" } }\n *\n * - Match all relationships with type \"KNOWS\" which have the property \"name\" equal to \"John\" and apply width 10\n *  { match: { reltype: \"KNOWS\" }, where: { equal: [{ property: \"name\" }, \"John\"] }, apply: { width: 10 } }\n */\n\n// Selector schemas. This is what can go under the `match` key.\nconst LabelSelectorSchema = z.object({\n  label: z.string().nullable(),\n});\n\nconst ReltypeSelectorSchema = z.object({\n  reltype: z.string().nullable(),\n});\n\nconst PropertySelectorSchema = z.object({\n  property: z.string(),\n});\n\nexport const SelectorSchema = z.union([\n  LabelSelectorSchema,\n  ReltypeSelectorSchema,\n  PropertySelectorSchema,\n]);\ntype Selector = z.infer<typeof SelectorSchema>;\n\nexport const MatchSchema = z.union([\n  LabelSelectorSchema,\n  ReltypeSelectorSchema,\n  PropertySelectorSchema,\n]);\n\n// Schemas for the values that can go under the `where` key. Starts with defining the literal values.\nexport const CypherValueSchema = z.union([\n  z.string(),\n  z.number(),\n  z.boolean(),\n  z.null(),\n]);\nexport type CypherValue = z.infer<typeof CypherValueSchema>;\n\nexport const ValueSchema = z\n  .union([SelectorSchema, CypherValueSchema])\n  .describe(\n    'Either a property/label/reltype selector (e.g., {property: \"name\"}) or a literal value (string, number, boolean, null).',\n  );\nexport type Value = z.infer<typeof ValueSchema>;\n\n/**\n * Where clause - recursive type for conditional expressions\n * The type is manually defined for the export, since zod doesn't support exporting inferred recursive types.\n */\n\nexport type Where =\n  // Selector is useful for finding nodes with multiple labels.\n  // for example: {match: {label: \"Person\"}, where: {label: \"Actor\"}}\n  // matches nodes with label Person AND Actor\n  | Selector\n  | { not: Where }\n  | { and: Where[] }\n  | { or: Where[] }\n  | { equal: [Value, Value] }\n  | { lessThan: [Value, Value] }\n  | { lessThanOrEqual: [Value, Value] }\n  | { greaterThan: [Value, Value] }\n  | { greaterThanOrEqual: [Value, Value] }\n  | { contains: [Value, Value] }\n  | { startsWith: [Value, Value] }\n  | { endsWith: [Value, Value] }\n\n  // Null check matching Cypher's IS NULL\n  // Returns true/false (not null), making it safe for null checking\n  // Use { not: { isNull: ... } } for IS NOT NULL\n  // @see https://neo4j.com/docs/cypher-manual/current/values-and-types/working-with-null/\n  | { isNull: Value };\n\nexport const WhereSchema: z.ZodType<Where> = z.lazy(() =>\n  z.union([\n    SelectorSchema,\n    z.object({ not: WhereSchema }),\n    z.object({ and: z.array(WhereSchema) }),\n    z.object({ or: z.array(WhereSchema) }),\n    z.object({ equal: z.tuple([ValueSchema, ValueSchema]) }),\n    z.object({ lessThan: z.tuple([ValueSchema, ValueSchema]) }),\n    z.object({ lessThanOrEqual: z.tuple([ValueSchema, ValueSchema]) }),\n    z.object({ greaterThan: z.tuple([ValueSchema, ValueSchema]) }),\n    z.object({ greaterThanOrEqual: z.tuple([ValueSchema, ValueSchema]) }),\n    z.object({ contains: z.tuple([ValueSchema, ValueSchema]) }),\n    z.object({ startsWith: z.tuple([ValueSchema, ValueSchema]) }),\n    z.object({ endsWith: z.tuple([ValueSchema, ValueSchema]) }),\n    z.object({ isNull: ValueSchema }),\n  ]),\n);\n\n// Schemas that go under the `apply` key.\nexport const CaptionValueSchema = z.union([\n  z.string(),\n  z.object({ property: z.string() }),\n  z.object({ useType: z.literal(true) }),\n]);\nexport type CaptionValue = z.infer<typeof CaptionValueSchema>;\n\nexport const CaptionVariationSchema = z.enum(['bold', 'italic', 'underline']);\nexport type CaptionVariation = z.infer<typeof CaptionVariationSchema>;\n\nexport const NvlCaptionSchema = z.object({\n  styles: z.array(z.string()).optional(),\n  value: CaptionValueSchema.optional(),\n  key: z.string().optional(),\n});\nexport type Caption = z.infer<typeof NvlCaptionSchema>;\n\n/**\n * OverlayIcon from NVL - icon displayed on top of a graph element\n * @see @neo4j-nvl/base Node.overlayIcon\n */\nconst NvlOverlayIconSchema = z.object({\n  url: z.string(),\n  position: z.array(z.number()).optional(),\n  size: z.number().optional(),\n});\n\nexport const StyleSchema = z.object({\n  captionAlign: z.enum(['top', 'bottom', 'center']).optional(),\n  captionSize: z.number().optional(),\n  captions: z.array(NvlCaptionSchema).optional(),\n  color: z.string().optional(),\n  icon: z.string().optional(),\n  overlayIcon: NvlOverlayIconSchema.optional(),\n  size: z.number().optional(),\n  width: z.number().optional(),\n});\nexport type Style = z.infer<typeof StyleSchema>;\n\nexport const StyleRuleSchema = z.object({\n  match: MatchSchema,\n  where: WhereSchema.optional(),\n  apply: StyleSchema,\n  disabled: z.boolean().optional(),\n  priority: z.number().optional(),\n});\nexport type StyleRule = z.infer<typeof StyleRuleSchema>;\n\n// Evaluated style values that NVL expects\nexport type EvaluatedNvlNodeStyle = Pick<\n  Node,\n  | 'icon'\n  | 'overlayIcon'\n  | 'color'\n  | 'size'\n  | 'captions'\n  | 'captionSize'\n  | 'captionAlign'\n>;\nexport type EvaluatedNvlRelationshipStyle = Pick<\n  Relationship,\n  | 'width'\n  | 'color'\n  | 'captions'\n  | 'captionSize'\n  | 'captionAlign'\n  | 'overlayIcon'\n>;\n"]}

package/lib/esm/styling/compile-graph-styles.js

@@ -0,0 +1,478 @@
+/**
+ *
+ *  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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { calculateDefaultNodeColors } from '@neo4j-devtools/word-color';
+import { tokens } from '@neo4j-ndl/base';
+function compareByPriorityAscending(a, b) {
+    return a.priority - b.priority;
+}
+function collectStyleMatchers(styles) {
+    const rulesByLabel = new Map();
+    const rulesByType = new Map();
+    const globalLabelRules = [];
+    const globalReltypeRules = [];
+    // Handle null/undefined styles gracefully
+    if (!styles || styles.length === 0) {
+        return {
+            globalLabelRules,
+            globalReltypeRules,
+            rulesByLabel,
+            rulesByType,
+        };
+    }
+    const totalRules = styles.length;
+    styles.forEach((style, index) => {
+        var _a, _b;
+        if ((_a = style.disabled) !== null && _a !== void 0 ? _a : false) {
+            return;
+        }
+        if (style.priority !== undefined && style.priority < 0) {
+            throw new Error(`StyleRule priority must be >= 0, got ${style.priority}. Negative values are reserved for internal use.`);
+        }
+        // Fill in priority if not set (negative values preserve original order)
+        const { priority } = style, rest = __rest(style, ["priority"]);
+        const ruleWithPriority = Object.assign(Object.assign({}, rest), { priority: priority !== null && priority !== void 0 ? priority : index - totalRules });
+        // style for nodes
+        if ('label' in style.match) {
+            // if the label is null/undefined, it's a global rule (matches any node)
+            if (style.match.label == null) {
+                globalLabelRules.push(ruleWithPriority);
+            }
+            else {
+                // Specific label rule
+                const existing = (_b = rulesByLabel.get(style.match.label)) !== null && _b !== void 0 ? _b : [];
+                rulesByLabel.set(style.match.label, [...existing, ruleWithPriority]);
+            }
+        }
+        // style for relationships
+        if ('reltype' in style.match) {
+            if (style.match.reltype === null) {
+                // Global reltype rule (matches any relationship)
+                globalReltypeRules.push(ruleWithPriority);
+            }
+            else {
+                // Specific reltype rule
+                const existing = rulesByType.get(style.match.reltype) || [];
+                rulesByType.set(style.match.reltype, [...existing, ruleWithPriority]);
+            }
+        }
+    });
+    return {
+        globalLabelRules,
+        globalReltypeRules,
+        rulesByLabel,
+        rulesByType,
+    };
+}
+function extractPropertyValue(prop) {
+    switch (prop.type) {
+        case 'string':
+            return JSON.parse(prop.stringified);
+        case 'number':
+        case 'integer':
+        case 'float':
+            return Number(prop.stringified);
+        case 'boolean':
+        case 'Boolean':
+            return prop.stringified === 'true';
+        case 'null':
+            return null;
+        default:
+            return prop.stringified;
+    }
+}
+/**
+ * Evaluates a WHERE clause using three-valued logic matching Cypher semantics.
+ *
+ * From Neo4j Cypher Manual:
+ * - Comparing any value to `null` results in `null`, not `true` or `false`
+ * - Accessing a non-existent property returns `null`
+ * - In WHERE clauses, only `true` passes; both `false` and `null` exclude the row
+ *
+ * Three-valued logic rules:
+ * - NOT null → null
+ * - true AND null → null, false AND null → false
+ * - true OR null → true, false OR null → null
+ *
+ * @see https://neo4j.com/docs/cypher-manual/current/values-and-types/working-with-null/
+ */
+function evaluateWhere(node, where) {
+    if (!where) {
+        return true;
+    }
+    if ('equal' in where) {
+        const [left, right] = where.equal;
+        const leftVal = evaluateValue(left, node);
+        const rightVal = evaluateValue(right, node);
+        // In Cypher, null = null → null (not true)
+        if (leftVal === null || rightVal === null) {
+            return null;
+        }
+        return leftVal === rightVal;
+    }
+    if ('not' in where) {
+        // Cypher: NOT null → null
+        const isMatch = evaluateWhere(node, where.not);
+        return isMatch === null ? null : !isMatch;
+    }
+    if ('lessThan' in where) {
+        const [left, right] = where.lessThan;
+        return safeCompare(left, right, node, (a, b) => a < b);
+    }
+    if ('lessThanOrEqual' in where) {
+        const [left, right] = where.lessThanOrEqual;
+        return safeCompare(left, right, node, (a, b) => a <= b);
+    }
+    if ('greaterThan' in where) {
+        const [left, right] = where.greaterThan;
+        return safeCompare(left, right, node, (a, b) => a > b);
+    }
+    if ('greaterThanOrEqual' in where) {
+        const [left, right] = where.greaterThanOrEqual;
+        return safeCompare(left, right, node, (a, b) => a >= b);
+    }
+    if ('contains' in where) {
+        const [left, right] = where.contains;
+        return safeStringCompare(left, right, node, (a, b) => a.includes(b));
+    }
+    if ('startsWith' in where) {
+        const [left, right] = where.startsWith;
+        return safeStringCompare(left, right, node, (a, b) => a.startsWith(b));
+    }
+    if ('endsWith' in where) {
+        const [left, right] = where.endsWith;
+        return safeStringCompare(left, right, node, (a, b) => a.endsWith(b));
+    }
+    if ('isNull' in where) {
+        // IS NULL returns true/false (never null)
+        const value = evaluateValue(where.isNull, node);
+        return value === null;
+    }
+    if ('and' in where) {
+        // Cypher three-valued AND:
+        // - If any is false → false
+        // - Else if any is null → null
+        // - Else → true
+        let hasNull = false;
+        for (const r of where.and) {
+            const isMatch = evaluateWhere(node, r);
+            if (isMatch === false) {
+                return false;
+            }
+            if (isMatch === null) {
+                hasNull = true;
+            }
+        }
+        return hasNull ? null : true;
+    }
+    if ('or' in where) {
+        // Cypher three-valued OR:
+        // - If any is true → true
+        // - Else if any is null → null
+        // - Else → false
+        let hasNull = false;
+        for (const r of where.or) {
+            const isMatch = evaluateWhere(node, r);
+            if (isMatch === true) {
+                return true;
+            }
+            if (isMatch === null) {
+                hasNull = true;
+            }
+        }
+        return hasNull ? null : false;
+    }
+    if ('label' in where) {
+        if ('labelsSorted' in node) {
+            return where.label === null || node.labelsSorted.includes(where.label);
+        }
+        return false;
+    }
+    if ('reltype' in where) {
+        if ('type' in node) {
+            return where.reltype === null || node.type === where.reltype;
+        }
+        return false;
+    }
+    if ('property' in where) {
+        return where.property === null || where.property in node.properties;
+    }
+    return false;
+}
+function evaluateRelStyle(apply, rel) {
+    var _a;
+    return Object.assign(Object.assign({}, apply), { captions: (_a = apply.captions) === null || _a === void 0 ? void 0 : _a.map((caption) => {
+            const { value, styles } = caption;
+            if (typeof value === 'string' || value === undefined) {
+                return { styles, value };
+            }
+            if ('useType' in value) {
+                return { styles, value: rel.type };
+            }
+            if ('property' in value) {
+                const prop = rel.properties[value.property];
+                if (prop === undefined) {
+                    return { styles, value: '' };
+                }
+                const resolvedValue = prop.type === 'string'
+                    ? prop.stringified.slice(1, -1)
+                    : prop.stringified;
+                return { styles, value: resolvedValue };
+            }
+            return { styles, value: rel.id };
+        }) });
+}
+/**
+ * Safely compare two values using Cypher's three-valued logic.
+ * Returns `null` if either operand is null (matching Cypher semantics).
+ *
+ * From Neo4j Cypher Manual:
+ * "Comparing any value to `null` using `=` or `<>` results in `null`"
+ *
+ * @see https://neo4j.com/docs/cypher-manual/current/values-and-types/working-with-null/
+ */
+function safeCompare(left, right, graphItem, compareFn) {
+    const leftVal = evaluateValue(left, graphItem);
+    const rightVal = evaluateValue(right, graphItem);
+    if (leftVal === null || rightVal === null) {
+        return null;
+    }
+    return compareFn(leftVal, rightVal);
+}
+/**
+ * String comparison using Cypher semantics.
+ * Returns `null` if either operand is null OR not a string.
+ *
+ * From Neo4j Cypher Manual:
+ * "When these operators are applied to non-string values, they return `null`
+ * instead of attempting type coercion."
+ *
+ * @see https://neo4j.com/docs/cypher-manual/current/expressions/predicates/string-operators/
+ */
+function safeStringCompare(left, right, graphItem, compareFn) {
+    const leftVal = evaluateValue(left, graphItem);
+    const rightVal = evaluateValue(right, graphItem);
+    // Return null if either is null or not a string (no type coercion)
+    if (leftVal === null ||
+        rightVal === null ||
+        typeof leftVal !== 'string' ||
+        typeof rightVal !== 'string') {
+        return null;
+    }
+    return compareFn(leftVal, rightVal);
+}
+function evaluateValue(value, graphItem) {
+    if (typeof value === 'object' && value !== null) {
+        if ('property' in value) {
+            if (value.property === null) {
+                return null;
+            }
+            const prop = graphItem.properties[value.property];
+            if (prop === undefined) {
+                return null;
+            }
+            return extractPropertyValue(prop);
+        }
+        if ('label' in value) {
+            if ('labelsSorted' in graphItem) {
+                return (value.label === null || graphItem.labelsSorted.includes(value.label));
+            }
+            return false;
+        }
+        if ('reltype' in value) {
+            if ('type' in graphItem) {
+                return (value.reltype === null ||
+                    graphItem.type === value.reltype);
+            }
+            return false;
+        }
+    }
+    return value;
+}
+// Default caption selection logic
+const captionPriorityOrder = [
+    /^name$/i,
+    /^title$/i,
+    /^label$/i,
+    /name$/i,
+    /description$/i,
+    /^.+/,
+];
+function getDefaultNodeCaption(node) {
+    const propertyKeys = Object.keys(node.properties);
+    for (const regex of captionPriorityOrder) {
+        const matchingKey = propertyKeys.find((key) => regex.test(key));
+        if (matchingKey !== undefined) {
+            const prop = node.properties[matchingKey];
+            if (prop !== undefined) {
+                return { value: { property: matchingKey } };
+            }
+        }
+    }
+    if (node.labelsSorted[0] !== undefined) {
+        return { value: { useType: true } };
+    }
+    return { value: { property: node.id } };
+}
+function evaluateNodeStyle(apply, node) {
+    var _a;
+    return Object.assign(Object.assign({}, apply), { captions: ((_a = apply.captions) !== null && _a !== void 0 ? _a : [getDefaultNodeCaption(node)]).map((caption) => {
+            const { value, styles } = caption;
+            if (typeof value === 'string' || value === undefined) {
+                return { styles, value };
+            }
+            if ('useType' in value) {
+                return { styles, value: node.labelsSorted[0] };
+            }
+            if ('property' in value) {
+                const prop = node.properties[value.property];
+                if (prop === undefined) {
+                    return { styles, value: '' };
+                }
+                const resolvedValue = prop.type === 'string'
+                    ? prop.stringified.slice(1, -1)
+                    : prop.stringified;
+                return { styles, value: resolvedValue };
+            }
+            return { styles, value: node.labelsSorted[0] };
+        }) });
+}
+function createRelStyleFunction(rules) {
+    return (rel) => {
+        const style = {};
+        // evaluateWhere uses Cypher-style three-valued logic (true/false/null).
+        // Only `true` passes; both `false` and `null` (unknown) skip the rule.
+        for (const rule of rules) {
+            // Check if the rule applies to this relationship
+            if ('reltype' in rule.match) {
+                const isReltypeMatch = rule.match.reltype === null || rel.type === rule.match.reltype;
+                if (isReltypeMatch && evaluateWhere(rel, rule.where) === true) {
+                    // Merge the style properties (later rules override earlier ones)
+                    Object.assign(style, rule.apply);
+                }
+            }
+        }
+        return evaluateRelStyle(style, rel);
+    };
+}
+export const DEFAULT_REL_COLOR = tokens.palette.neutral['40'];
+const NO_LABEL_FALLBACK_COLOR = tokens.palette.neutral['40'];
+function createByLabelSetFunction(styleMatchers) {
+    // Memoize default color by label string (idea 2: avoid recalculating per node)
+    const defaultColorCache = new Map();
+    // Cache sorted rules by label set key (idea 1: avoid allocation + sort per node)
+    const sortedRulesCache = new Map();
+    // Cache merged Style for where-free rule sets (idea 3: skip rule iteration entirely)
+    const mergedStyleCache = new Map();
+    return (node) => {
+        var _a;
+        const labelSetKey = node.labelsSorted.join('\0');
+        // Fast path: if all rules for this label set are where-free,
+        // the merged style is identical for every node with the same labels.
+        const cachedStyle = mergedStyleCache.get(labelSetKey);
+        if (cachedStyle !== undefined) {
+            return evaluateNodeStyle(cachedStyle, node);
+        }
+        // Memoize default color by first label
+        const labelForDefaultColor = (_a = node.labelsSorted[0]) !== null && _a !== void 0 ? _a : null;
+        let defaultColor;
+        if (labelForDefaultColor === null) {
+            defaultColor = NO_LABEL_FALLBACK_COLOR;
+        }
+        else {
+            let cached = defaultColorCache.get(labelForDefaultColor);
+            if (cached === undefined) {
+                cached =
+                    calculateDefaultNodeColors(labelForDefaultColor).backgroundColor;
+                defaultColorCache.set(labelForDefaultColor, cached);
+            }
+            defaultColor = cached;
+        }
+        // Cache sorted rules by label set (avoids repeated allocation + sort)
+        let sortedRules = sortedRulesCache.get(labelSetKey);
+        if (sortedRules === undefined) {
+            const matchingRules = [...styleMatchers.globalLabelRules];
+            for (const label of node.labelsSorted) {
+                const labelRules = styleMatchers.rulesByLabel.get(label);
+                if (labelRules) {
+                    matchingRules.push(...labelRules);
+                }
+            }
+            sortedRules = matchingRules.toSorted(compareByPriorityAscending);
+            sortedRulesCache.set(labelSetKey, sortedRules);
+        }
+        // Evaluate rules, tracking whether all are where-free
+        const collectStyles = { color: defaultColor };
+        let isAllWhereFree = true;
+        for (const rule of sortedRules) {
+            if (rule.where !== undefined) {
+                isAllWhereFree = false;
+                if (evaluateWhere(node, rule.where) === true) {
+                    Object.assign(collectStyles, rule.apply);
+                }
+            }
+            else {
+                Object.assign(collectStyles, rule.apply);
+            }
+        }
+        // When all rules are where-free, the merged style depends only on labels.
+        // Cache it so subsequent nodes with the same label set skip rule iteration.
+        if (isAllWhereFree) {
+            mergedStyleCache.set(labelSetKey, collectStyles);
+        }
+        return evaluateNodeStyle(collectStyles, node);
+    };
+}
+const DEFAULT_REL_STYLE = {
+    match: { reltype: null },
+    apply: {
+        color: DEFAULT_REL_COLOR,
+        captions: [{ value: { useType: true } }],
+    },
+};
+export function compileStyleRules({ reltypes, styleRules, }) {
+    var _a;
+    const styleMatchers = collectStyleMatchers(styleRules);
+    // as relationships can only have one type, we can use a map to store the style function for each type
+    const byType = new Map();
+    // Compile relationship type-based rules
+    for (const reltype of reltypes) {
+        const rules = (_a = styleMatchers.rulesByType.get(reltype)) !== null && _a !== void 0 ? _a : [];
+        byType.set(reltype, createRelStyleFunction([
+            DEFAULT_REL_STYLE,
+            ...styleMatchers.globalReltypeRules,
+            ...rules,
+        ]));
+    }
+    const byLabelSet = createByLabelSetFunction(styleMatchers);
+    return { byLabelSet, byType, styleMatchers };
+}
+//# sourceMappingURL=compile-graph-styles.js.map