@deck.gl-community/graph-layers 9.2.0-beta.6 → 9.2.5

package/dist/index.cjs

@@ -2249,56 +2249,10 @@ var StylesheetEngine = class {
   }
 };
 
-// dist/style/graph-stylesheet.schema.js
+// dist/style/graph-stylesheet-schema.js
 var import_zod = require("zod");
-var GraphStylePrimitiveSchema = import_zod.z.union([
-  import_zod.z.string(),
-  import_zod.z.number(),
-  import_zod.z.boolean(),
-  import_zod.z.null(),
-  import_zod.z.array(import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean(), import_zod.z.null()]))
-]);
-var GraphStyleFunctionSchema = import_zod.z.custom((value) => typeof value === "function", {
-  message: "Style functions must be callable."
-});
-var GraphStyleScaleTypeEnum = import_zod.z.enum([
-  "linear",
-  "log",
-  "pow",
-  "sqrt",
-  "quantize",
-  "quantile",
-  "ordinal"
-]);
-var GraphStyleScaleSchema = import_zod.z.object({
-  type: GraphStyleScaleTypeEnum.optional(),
-  domain: import_zod.z.array(import_zod.z.union([import_zod.z.number(), import_zod.z.string()])).optional(),
-  range: import_zod.z.array(import_zod.z.any()).optional(),
-  clamp: import_zod.z.boolean().optional(),
-  nice: import_zod.z.union([import_zod.z.boolean(), import_zod.z.number()]).optional(),
-  base: import_zod.z.number().optional(),
-  exponent: import_zod.z.number().optional(),
-  unknown: import_zod.z.any().optional()
-}).strict();
-var GraphStyleAttributeReferenceSchema = import_zod.z.union([
-  import_zod.z.string().regex(/^@.+/, 'Attribute reference strings must start with "@" and include an attribute name.'),
-  import_zod.z.object({
-    attribute: import_zod.z.string().min(1, "Attribute name is required."),
-    fallback: GraphStylePrimitiveSchema.optional(),
-    scale: import_zod.z.union([GraphStyleScaleSchema, GraphStyleFunctionSchema]).optional()
-  }).strict()
-]);
-var GraphStyleLeafValueSchema = import_zod.z.union([
-  GraphStylePrimitiveSchema,
-  GraphStyleAttributeReferenceSchema,
-  GraphStyleFunctionSchema
-]);
-var RESERVED_STATE_KEYS = /* @__PURE__ */ new Set(["attribute", "fallback", "scale"]);
-var GraphStyleStateMapSchema = import_zod.z.record(import_zod.z.string().refine((key) => !RESERVED_STATE_KEYS.has(key), "State overrides must not use reserved keys."), GraphStyleLeafValueSchema);
-var GraphStyleValueSchema = import_zod.z.union([
-  GraphStyleLeafValueSchema,
-  GraphStyleStateMapSchema
-]);
+
+// dist/style/graph-style-accessor-map.js
 var COMMON_DECKGL_PROPS = {
   getOffset: "offset",
   opacity: "opacity"
@@ -2389,32 +2343,66 @@ var GRAPH_DECKGL_ACCESSOR_MAP = {
     getOffset: "offset"
   }
 };
+
+// dist/style/graph-stylesheet-schema.js
+var GraphStylePrimitiveSchema = import_zod.z.union([
+  import_zod.z.string(),
+  import_zod.z.number(),
+  import_zod.z.boolean(),
+  import_zod.z.null(),
+  import_zod.z.array(import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean(), import_zod.z.null()]))
+]);
+var GraphStyleFunctionSchema = import_zod.z.custom((value) => typeof value === "function", {
+  message: "Style functions must be callable."
+});
+var GraphStyleScaleTypeEnum = import_zod.z.enum([
+  "linear",
+  "log",
+  "pow",
+  "sqrt",
+  "quantize",
+  "quantile",
+  "ordinal"
+]);
+var GraphStyleScaleSchema = import_zod.z.object({
+  type: GraphStyleScaleTypeEnum.optional(),
+  domain: import_zod.z.array(import_zod.z.union([import_zod.z.number(), import_zod.z.string()])).optional(),
+  range: import_zod.z.array(import_zod.z.any()).optional(),
+  clamp: import_zod.z.boolean().optional(),
+  nice: import_zod.z.union([import_zod.z.boolean(), import_zod.z.number()]).optional(),
+  base: import_zod.z.number().optional(),
+  exponent: import_zod.z.number().optional(),
+  unknown: import_zod.z.any().optional()
+}).strict();
+var GraphStyleAttributeReferenceSchema = import_zod.z.union([
+  import_zod.z.string().regex(/^@.+/, 'Attribute reference strings must start with "@" and include an attribute name.'),
+  import_zod.z.object({
+    attribute: import_zod.z.string().min(1, "Attribute name is required."),
+    fallback: GraphStylePrimitiveSchema.optional(),
+    scale: import_zod.z.union([GraphStyleScaleSchema, GraphStyleFunctionSchema]).optional()
+  }).strict()
+]);
+var GraphStyleLeafValueSchema = import_zod.z.union([
+  GraphStylePrimitiveSchema,
+  GraphStyleAttributeReferenceSchema,
+  GraphStyleFunctionSchema
+]);
+var RESERVED_STATE_KEYS = /* @__PURE__ */ new Set(["attribute", "fallback", "scale"]);
+var GraphStyleStateMapSchema = import_zod.z.record(import_zod.z.string().refine((key) => !RESERVED_STATE_KEYS.has(key), "State overrides must not use reserved keys."), GraphStyleLeafValueSchema);
+var GraphStyleValueSchema = import_zod.z.union([GraphStyleLeafValueSchema, GraphStyleStateMapSchema]);
 var GraphStyleSelectorKeySchema = import_zod.z.string().regex(/^:[^\s]+/, 'Selectors must start with ":".');
-function createPropertiesSchema(keys) {
-  const shape = keys.reduce((acc, key) => {
-    acc[key] = GraphStyleValueSchema.optional();
-    return acc;
-  }, {});
-  return import_zod.z.object(shape).partial().strict();
-}
-var GraphStylesheetVariants = Object.entries(GRAPH_DECKGL_ACCESSOR_MAP).map(([type, accessors]) => {
-  const propertyKeys = Object.values(accessors);
-  const propertyKeySet = new Set(propertyKeys);
-  const propertiesSchema = createPropertiesSchema(propertyKeys);
-  const baseShape = {
-    type: import_zod.z.literal(type)
-  };
-  for (const key of propertyKeys) {
-    baseShape[key] = GraphStyleValueSchema.optional();
-  }
-  return import_zod.z.object(baseShape).catchall(import_zod.z.unknown()).superRefine((value, ctx) => {
-    for (const key of Object.keys(value)) {
-      if (key === "type") {
+function createSelectorRefinement(allowedKeys, propertiesSchema) {
+  const allowedKeySet = new Set(allowedKeys);
+  return (value, ctx) => {
+    if (typeof value !== "object" || value === null) {
+      return;
+    }
+    const record = value;
+    for (const key of Object.keys(record)) {
+      if (key === "type")
         continue;
-      }
-      if (propertyKeySet.has(key)) {
+      if (allowedKeySet.has(key))
         continue;
-      }
       if (!key.startsWith(":")) {
         ctx.addIssue({
           code: import_zod.z.ZodIssueCode.custom,
@@ -2431,7 +2419,7 @@ var GraphStylesheetVariants = Object.entries(GRAPH_DECKGL_ACCESSOR_MAP).map(([ty
         });
         continue;
       }
-      const selectorResult = propertiesSchema.safeParse(value[key]);
+      const selectorResult = propertiesSchema.safeParse(record[key]);
       if (!selectorResult.success) {
         for (const issue of selectorResult.error.issues) {
           ctx.addIssue({
@@ -2441,101 +2429,190 @@ var GraphStylesheetVariants = Object.entries(GRAPH_DECKGL_ACCESSOR_MAP).map(([ty
         }
       }
     }
-  });
-});
-var GraphStylesheetSchema = import_zod.z.discriminatedUnion("type", GraphStylesheetVariants);
-
-// dist/style/graph-style-accessor-map.js
-var COMMON_DECKGL_PROPS2 = {
-  getOffset: "offset",
-  opacity: "opacity"
+  };
+}
+var CircleShape = {
+  offset: GraphStyleValueSchema.optional(),
+  opacity: GraphStyleValueSchema.optional(),
+  fill: GraphStyleValueSchema.optional(),
+  stroke: GraphStyleValueSchema.optional(),
+  strokeWidth: GraphStyleValueSchema.optional(),
+  radius: GraphStyleValueSchema.optional()
 };
-var GRAPH_DECKGL_ACCESSOR_MAP2 = {
-  circle: {
-    ...COMMON_DECKGL_PROPS2,
-    getFillColor: "fill",
-    getLineColor: "stroke",
-    getLineWidth: "strokeWidth",
-    getRadius: "radius"
-  },
-  rectangle: {
-    ...COMMON_DECKGL_PROPS2,
-    getWidth: "width",
-    getHeight: "height",
-    getFillColor: "fill",
-    getLineColor: "stroke",
-    getLineWidth: "strokeWidth"
-  },
-  "rounded-rectangle": {
-    ...COMMON_DECKGL_PROPS2,
-    getCornerRadius: "cornerRadius",
-    getRadius: "radius",
-    getWidth: "width",
-    getHeight: "height",
-    getFillColor: "fill",
-    getLineColor: "stroke",
-    getLineWidth: "strokeWidth"
-  },
-  "path-rounded-rectangle": {
-    ...COMMON_DECKGL_PROPS2,
-    getWidth: "width",
-    getHeight: "height",
-    getFillColor: "fill",
-    getLineColor: "stroke",
-    getLineWidth: "strokeWidth",
-    getCornerRadius: "cornerRadius"
-  },
-  label: {
-    ...COMMON_DECKGL_PROPS2,
-    getColor: "color",
-    getText: "text",
-    getSize: "fontSize",
-    getTextAnchor: "textAnchor",
-    getAlignmentBaseline: "alignmentBaseline",
-    getAngle: "angle",
-    scaleWithZoom: "scaleWithZoom",
-    textMaxWidth: "textMaxWidth",
-    textWordBreak: "textWordBreak",
-    textSizeMinPixels: "textSizeMinPixels"
-  },
-  marker: {
-    ...COMMON_DECKGL_PROPS2,
-    getColor: "fill",
-    getSize: "size",
-    getMarker: "marker",
-    scaleWithZoom: "scaleWithZoom"
-  },
-  Edge: {
-    getColor: "stroke",
-    getWidth: "strokeWidth"
-  },
-  edge: {
-    getColor: "stroke",
-    getWidth: "strokeWidth"
-  },
-  "edge-label": {
-    getColor: "color",
-    getText: "text",
-    getSize: "fontSize",
-    getTextAnchor: "textAnchor",
-    getAlignmentBaseline: "alignmentBaseline",
-    scaleWithZoom: "scaleWithZoom",
-    textMaxWidth: "textMaxWidth",
-    textWordBreak: "textWordBreak",
-    textSizeMinPixels: "textSizeMinPixels"
-  },
-  flow: {
-    getColor: "color",
-    getWidth: "width",
-    getSpeed: "speed",
-    getTailLength: "tailLength"
-  },
-  arrow: {
-    getColor: "color",
-    getSize: "size",
-    getOffset: "offset"
-  }
+var CirclePropertiesSchema = import_zod.z.object(CircleShape).partial().strict();
+var CircleStylesheetSchema = import_zod.z.object({
+  type: import_zod.z.literal("circle"),
+  ...CircleShape
+}).catchall(import_zod.z.unknown()).superRefine(createSelectorRefinement(Object.keys(CircleShape), CirclePropertiesSchema));
+var RectangleShape = {
+  offset: GraphStyleValueSchema.optional(),
+  opacity: GraphStyleValueSchema.optional(),
+  width: GraphStyleValueSchema.optional(),
+  height: GraphStyleValueSchema.optional(),
+  fill: GraphStyleValueSchema.optional(),
+  stroke: GraphStyleValueSchema.optional(),
+  strokeWidth: GraphStyleValueSchema.optional()
+};
+var RectanglePropertiesSchema = import_zod.z.object(RectangleShape).partial().strict();
+var RectangleStylesheetSchema = import_zod.z.object({
+  type: import_zod.z.literal("rectangle"),
+  ...RectangleShape
+}).catchall(import_zod.z.unknown()).superRefine(createSelectorRefinement(Object.keys(RectangleShape), RectanglePropertiesSchema));
+var RoundedRectangleShape = {
+  offset: GraphStyleValueSchema.optional(),
+  opacity: GraphStyleValueSchema.optional(),
+  cornerRadius: GraphStyleValueSchema.optional(),
+  radius: GraphStyleValueSchema.optional(),
+  width: GraphStyleValueSchema.optional(),
+  height: GraphStyleValueSchema.optional(),
+  fill: GraphStyleValueSchema.optional(),
+  stroke: GraphStyleValueSchema.optional(),
+  strokeWidth: GraphStyleValueSchema.optional()
+};
+var RoundedRectanglePropertiesSchema = import_zod.z.object(RoundedRectangleShape).partial().strict();
+var RoundedRectangleStylesheetSchema = import_zod.z.object({
+  type: import_zod.z.literal("rounded-rectangle"),
+  ...RoundedRectangleShape
+}).catchall(import_zod.z.unknown()).superRefine(createSelectorRefinement(Object.keys(RoundedRectangleShape), RoundedRectanglePropertiesSchema));
+var PathRoundedRectangleShape = {
+  offset: GraphStyleValueSchema.optional(),
+  opacity: GraphStyleValueSchema.optional(),
+  width: GraphStyleValueSchema.optional(),
+  height: GraphStyleValueSchema.optional(),
+  fill: GraphStyleValueSchema.optional(),
+  stroke: GraphStyleValueSchema.optional(),
+  strokeWidth: GraphStyleValueSchema.optional(),
+  cornerRadius: GraphStyleValueSchema.optional()
+};
+var PathRoundedRectanglePropertiesSchema = import_zod.z.object(PathRoundedRectangleShape).partial().strict();
+var PathRoundedRectangleStylesheetSchema = import_zod.z.object({
+  type: import_zod.z.literal("path-rounded-rectangle"),
+  ...PathRoundedRectangleShape
+}).catchall(import_zod.z.unknown()).superRefine(createSelectorRefinement(Object.keys(PathRoundedRectangleShape), PathRoundedRectanglePropertiesSchema));
+var LabelShape = {
+  offset: GraphStyleValueSchema.optional(),
+  opacity: GraphStyleValueSchema.optional(),
+  color: GraphStyleValueSchema.optional(),
+  text: GraphStyleValueSchema.optional(),
+  fontSize: GraphStyleValueSchema.optional(),
+  textAnchor: GraphStyleValueSchema.optional(),
+  alignmentBaseline: GraphStyleValueSchema.optional(),
+  angle: GraphStyleValueSchema.optional(),
+  scaleWithZoom: GraphStyleValueSchema.optional(),
+  textMaxWidth: GraphStyleValueSchema.optional(),
+  textWordBreak: GraphStyleValueSchema.optional(),
+  textSizeMinPixels: GraphStyleValueSchema.optional()
+};
+var LabelPropertiesSchema = import_zod.z.object(LabelShape).partial().strict();
+var LabelStylesheetSchema = import_zod.z.object({
+  type: import_zod.z.literal("label"),
+  ...LabelShape
+}).catchall(import_zod.z.unknown()).superRefine(createSelectorRefinement(Object.keys(LabelShape), LabelPropertiesSchema));
+var MarkerShape = {
+  offset: GraphStyleValueSchema.optional(),
+  opacity: GraphStyleValueSchema.optional(),
+  fill: GraphStyleValueSchema.optional(),
+  size: GraphStyleValueSchema.optional(),
+  marker: GraphStyleValueSchema.optional(),
+  scaleWithZoom: GraphStyleValueSchema.optional()
+};
+var MarkerPropertiesSchema = import_zod.z.object(MarkerShape).partial().strict();
+var MarkerStylesheetSchema = import_zod.z.object({
+  type: import_zod.z.literal("marker"),
+  ...MarkerShape
+}).catchall(import_zod.z.unknown()).superRefine(createSelectorRefinement(Object.keys(MarkerShape), MarkerPropertiesSchema));
+var EdgeUpperShape = {
+  stroke: GraphStyleValueSchema.optional(),
+  strokeWidth: GraphStyleValueSchema.optional()
+};
+var EdgeUpperPropertiesSchema = import_zod.z.object(EdgeUpperShape).partial().strict();
+var EdgeUpperStylesheetSchema = import_zod.z.object({
+  type: import_zod.z.literal("Edge"),
+  ...EdgeUpperShape
+}).catchall(import_zod.z.unknown()).superRefine(createSelectorRefinement(Object.keys(EdgeUpperShape), EdgeUpperPropertiesSchema));
+var EdgeLowerShape = {
+  stroke: GraphStyleValueSchema.optional(),
+  strokeWidth: GraphStyleValueSchema.optional()
+};
+var EdgeLowerPropertiesSchema = import_zod.z.object(EdgeLowerShape).partial().strict();
+var EdgeLowerStylesheetSchema = import_zod.z.object({
+  type: import_zod.z.literal("edge"),
+  ...EdgeLowerShape
+}).catchall(import_zod.z.unknown()).superRefine(createSelectorRefinement(Object.keys(EdgeLowerShape), EdgeLowerPropertiesSchema));
+var EdgeLabelShape = {
+  color: GraphStyleValueSchema.optional(),
+  text: GraphStyleValueSchema.optional(),
+  fontSize: GraphStyleValueSchema.optional(),
+  textAnchor: GraphStyleValueSchema.optional(),
+  alignmentBaseline: GraphStyleValueSchema.optional(),
+  scaleWithZoom: GraphStyleValueSchema.optional(),
+  textMaxWidth: GraphStyleValueSchema.optional(),
+  textWordBreak: GraphStyleValueSchema.optional(),
+  textSizeMinPixels: GraphStyleValueSchema.optional()
 };
+var EdgeLabelPropertiesSchema = import_zod.z.object(EdgeLabelShape).partial().strict();
+var EdgeLabelStylesheetSchema = import_zod.z.object({
+  type: import_zod.z.literal("edge-label"),
+  ...EdgeLabelShape
+}).catchall(import_zod.z.unknown()).superRefine(createSelectorRefinement(Object.keys(EdgeLabelShape), EdgeLabelPropertiesSchema));
+var FlowShape = {
+  color: GraphStyleValueSchema.optional(),
+  width: GraphStyleValueSchema.optional(),
+  speed: GraphStyleValueSchema.optional(),
+  tailLength: GraphStyleValueSchema.optional()
+};
+var FlowPropertiesSchema = import_zod.z.object(FlowShape).partial().strict();
+var FlowStylesheetSchema = import_zod.z.object({
+  type: import_zod.z.literal("flow"),
+  ...FlowShape
+}).catchall(import_zod.z.unknown()).superRefine(createSelectorRefinement(Object.keys(FlowShape), FlowPropertiesSchema));
+var ArrowShape = {
+  color: GraphStyleValueSchema.optional(),
+  size: GraphStyleValueSchema.optional(),
+  offset: GraphStyleValueSchema.optional()
+};
+var ArrowPropertiesSchema = import_zod.z.object(ArrowShape).partial().strict();
+var ArrowStylesheetSchema = import_zod.z.object({
+  type: import_zod.z.literal("arrow"),
+  ...ArrowShape
+}).catchall(import_zod.z.unknown()).superRefine(createSelectorRefinement(Object.keys(ArrowShape), ArrowPropertiesSchema));
+var GraphNodeStylesheetVariants = [
+  CircleStylesheetSchema,
+  RectangleStylesheetSchema,
+  RoundedRectangleStylesheetSchema,
+  PathRoundedRectangleStylesheetSchema,
+  LabelStylesheetSchema,
+  MarkerStylesheetSchema
+];
+var GraphEdgeStylesheetVariants = [
+  EdgeUpperStylesheetSchema,
+  EdgeLowerStylesheetSchema,
+  EdgeLabelStylesheetSchema,
+  FlowStylesheetSchema,
+  ArrowStylesheetSchema
+];
+var GraphStyleRuleVariants = [...GraphNodeStylesheetVariants, ...GraphEdgeStylesheetVariants];
+var GraphStyleRuleSchema = import_zod.z.discriminatedUnion("type", GraphStyleRuleVariants);
+var GraphNodeStyleRuleSchema = import_zod.z.discriminatedUnion("type", GraphNodeStylesheetVariants);
+var GraphEdgeDecoratorRuleSchema = import_zod.z.discriminatedUnion("type", [
+  EdgeLabelStylesheetSchema,
+  FlowStylesheetSchema,
+  ArrowStylesheetSchema
+]);
+var EdgeUpperWithDecoratorsSchema = EdgeUpperStylesheetSchema.safeExtend({
+  decorators: import_zod.z.array(GraphEdgeDecoratorRuleSchema).optional()
+});
+var EdgeLowerWithDecoratorsSchema = EdgeLowerStylesheetSchema.safeExtend({
+  decorators: import_zod.z.array(GraphEdgeDecoratorRuleSchema).optional()
+});
+var GraphEdgeRuleWithDecoratorsSchema = import_zod.z.discriminatedUnion("type", [
+  EdgeUpperWithDecoratorsSchema,
+  EdgeLowerWithDecoratorsSchema
+]);
+var GraphStylesheetSchema = import_zod.z.object({
+  nodes: import_zod.z.array(GraphNodeStyleRuleSchema).optional(),
+  edges: import_zod.z.array(GraphEdgeRuleWithDecoratorsSchema).optional()
+}).strict();
 
 // dist/style/graph-style-engine.js
 var GRAPH_DECKGL_UPDATE_TRIGGERS = {
@@ -2561,10 +2638,10 @@ ${details}`;
 }
 var GraphStylesheetEngine = class extends StylesheetEngine {
   constructor(style, { stateUpdateTrigger } = {}) {
-    const result = GraphStylesheetSchema.safeParse(style);
+    const result = GraphStyleRuleSchema.safeParse(style);
     const parsedStyle = result.success ? result.data : sanitizeStylesheet(style, result.error.issues);
     super(parsedStyle, {
-      deckglAccessorMap: GRAPH_DECKGL_ACCESSOR_MAP2,
+      deckglAccessorMap: GRAPH_DECKGL_ACCESSOR_MAP,
       deckglUpdateTriggers: GRAPH_DECKGL_UPDATE_TRIGGERS,
       stateUpdateTrigger
     });
@@ -2606,7 +2683,7 @@ function sanitizeStylesheet(style, issues) {
       }
       delete sanitized[rootKey];
     }
-    const result = GraphStylesheetSchema.safeParse(sanitized);
+    const result = GraphStyleRuleSchema.safeParse(sanitized);
     if (result.success) {
       return result.data;
     }
@@ -2756,6 +2833,7 @@ var GraphEngine = class {
     var _a, _b, _c, _d;
     return ((_b = (_a = this._graph).findNode) == null ? void 0 : _b.call(_a, nodeId)) ?? ((_d = (_c = this._graph).findNodeById) == null ? void 0 : _d.call(_c, nodeId));
   }
+  /** Creates a stylesheet engine for a single validated or raw style rule. */
   createStylesheetEngine(style, options = {}) {
     return new GraphStylesheetEngine(style, options);
   }
@@ -2945,7 +3023,10 @@ var _SimpleLayout = class extends GraphLayout {
     this._graph = graph;
     const nodes = Array.from(graph.getNodes());
     this._nodeMap = new Map(nodes.map((node) => [node.getId(), node]));
-    this._nodePositionMap = new Map(nodes.map((node) => [node.getId(), this._normalizePosition(this.props.nodePositionAccessor(node))]));
+    this._nodePositionMap = new Map(nodes.map((node) => [
+      node.getId(),
+      this._normalizePosition(this.props.nodePositionAccessor(node))
+    ]));
   }
   setNodePositionAccessor = (accessor) => {
     this.props.nodePositionAccessor = accessor;
@@ -3536,7 +3617,10 @@ var _D3DagLayout = class extends GraphLayout {
       if (!edge) {
         continue;
       }
-      const points = link.points && link.points.length ? link.points : [[link.source.x ?? 0, link.source.y ?? 0], [link.target.x ?? 0, link.target.y ?? 0]];
+      const points = link.points && link.points.length ? link.points : [
+        [link.source.x ?? 0, link.source.y ?? 0],
+        [link.target.x ?? 0, link.target.y ?? 0]
+      ];
       this._rawEdgePoints.set(edge.getId(), points.map((point) => [...point]));
     }
     this._updateTransformedGeometry();
@@ -4633,10 +4717,18 @@ var import_core18 = require("@deck.gl/core");
 var import_layers13 = require("@deck.gl/layers");
 
 // dist/style/graph-layer-stylesheet.js
+var DEFAULT_GRAPH_LAYER_STYLESHEET_INPUT = {
+  nodes: [],
+  edges: [
+    {
+      type: "edge",
+      stroke: "black",
+      strokeWidth: 1
+    }
+  ]
+};
 var DEFAULT_EDGE_STYLE = {
-  type: "edge",
-  stroke: "black",
-  strokeWidth: 1,
+  ...DEFAULT_GRAPH_LAYER_STYLESHEET_INPUT.edges[0],
   decorators: []
 };
 var DEFAULT_GRAPH_LAYER_STYLESHEET = {
@@ -5704,8 +5796,8 @@ __publicField(CurvedEdgeLayer, "layerName", "CurvedEdgeLayer");
 
 // dist/layers/edge-layer.js
 var EDGE_LAYER_MAP = {
-  "line": StraightLineEdgeLayer,
-  "path": PathEdgeLayer,
+  line: StraightLineEdgeLayer,
+  path: PathEdgeLayer,
   "spline-curve": CurvedEdgeLayer
 };
 var EdgeLayer = class extends import_core13.CompositeLayer {
@@ -5722,8 +5814,8 @@ var EdgeLayer = class extends import_core13.CompositeLayer {
       res[type].push(d);
       return res;
     }, {
-      "line": [],
-      "path": [],
+      line: [],
+      path: [],
       "spline-curve": []
     });
     this.setState({ typedEdgeData });
@@ -6062,14 +6154,7 @@ function getArrowAttributes({ length = 1, headWidth = 1 }) {
     0
   ]);
   const normals = new Float32Array([0, 0, 1, 0, 0, 1, 0, 0, 1]);
-  const texCoords = new Float32Array([
-    0.5,
-    1,
-    0,
-    0,
-    1,
-    0
-  ]);
+  const texCoords = new Float32Array([0.5, 1, 0, 0, 1, 0]);
   return {
     positions: { size: 3, value: positions },
     normals: { size: 3, value: normals },
@@ -6667,31 +6752,6 @@ __publicField(GridLayer, "defaultProps", {
   labelOffset: DEFAULT_OFFSET
 });
 
-// dist/loaders/json-graph-loader.js
-var VERSION = true ? "9.2.0-beta.6" : "latest";
-var JSONGraphLoader = {
-  dataType: null,
-  batchType: null,
-  name: "DOT Graph",
-  id: "dot-graph",
-  module: "graph-layers",
-  version: VERSION,
-  worker: false,
-  extensions: ["json"],
-  mimeTypes: ["application/json"],
-  text: true,
-  options: {
-    "jsongraph": {}
-  },
-  parse: async (arrayBuffer, options) => {
-    const text = new TextDecoder().decode(arrayBuffer);
-    return Promise.resolve(JSONGraphLoader.parseTextSync(text, options));
-  },
-  parseTextSync: (text, options) => {
-    throw new Error("JSONGraphLoader.parseTextSync not implemented");
-  }
-};
-
 // dist/utils/layer-utils.js
 var mixedGetPosition = (getPosition, getOffset2) => {
   if (!getOffset2) {
@@ -7382,20 +7442,34 @@ function selectRankLines(ranks, { yMin, yMax, maxCount = 8 }) {
   return selected.map((index) => filtered[index]);
 }
 
+// dist/graph-data/graph-data.js
+function isArrowGraphData(value) {
+  const candidate = value;
+  return typeof value === "object" && (candidate == null ? void 0 : candidate.shape) === "arrow-graph-data";
+}
+
+// dist/graph/functions/create-graph-from-data.js
+function createGraphFromData(data, props = {}) {
+  if (isArrowGraphData(data)) {
+    return new ArrowGraph({ ...props, data });
+  }
+  return new ClassicGraph({ ...props, data });
+}
+
 // dist/layers/graph-layer.js
 var NODE_LAYER_MAP = {
-  "rectangle": RectangleLayer,
+  rectangle: RectangleLayer,
   "rounded-rectangle": RoundedRectangleLayer,
   "path-rounded-rectangle": PathBasedRoundedRectangleLayer,
-  "icon": ImageLayer,
-  "circle": CircleLayer,
-  "label": LabelLayer,
-  "marker": ZoomableMarkerLayer
+  icon: ImageLayer,
+  circle: CircleLayer,
+  label: LabelLayer,
+  marker: ZoomableMarkerLayer
 };
 var EDGE_DECORATOR_LAYER_MAP = {
   "edge-label": EdgeLabelLayer,
-  "flow": FlowLayer,
-  "arrow": EdgeArrowLayer
+  flow: FlowLayer,
+  arrow: EdgeArrowLayer
 };
 var SHARED_LAYER_PROPS = {
   coordinateSystem: import_core18.COORDINATE_SYSTEM.CARTESIAN,
@@ -7411,6 +7485,12 @@ var NODE_STYLE_DEPRECATION_WARNED = false;
 var EDGE_STYLE_DEPRECATION_WARNED = false;
 var GRAPH_PROP_DEPRECATION_WARNED = false;
 var LAYOUT_REQUIRED_WARNED = false;
+var DEFAULT_GRAPH_LOADER = ({ json }) => {
+  if (!json || typeof json !== "object") {
+    return null;
+  }
+  return createGraphFromData(json);
+};
 var _GraphLayer = class extends import_core18.CompositeLayer {
   // @ts-expect-error Some typescript confusion due to override of base class state
   state;
@@ -7605,7 +7685,7 @@ var _GraphLayer = class extends import_core18.CompositeLayer {
       return void 0;
     }
     if (Array.isArray(data) || isPlainObject(data)) {
-      const loader = props.graphLoader ?? JSONGraphLoader;
+      const loader = props.graphLoader ?? DEFAULT_GRAPH_LOADER;
       const graph = loader({ json: data });
       if (!graph) {
         return null;
@@ -8090,12 +8170,11 @@ var GraphLayer = _GraphLayer;
 __publicField(GraphLayer, "layerName", "GraphLayer");
 __publicField(GraphLayer, "defaultProps", {
   // Composite layer props
-  // @ts-expect-error composite layer props
   pickable: true,
   data: { type: "object", value: null, async: true },
   // Graph props
-  graphLoader: JSONGraphLoader,
-  stylesheet: DEFAULT_GRAPH_LAYER_STYLESHEET,
+  graphLoader: DEFAULT_GRAPH_LOADER,
+  stylesheet: DEFAULT_GRAPH_LAYER_STYLESHEET_INPUT,
   nodeStyle: void 0,
   nodeEvents: {
     onMouseLeave: () => {
@@ -8128,8 +8207,33 @@ function isPlainObject(value) {
   return prototype === Object.prototype || prototype === null;
 }
 
+// dist/loaders/json-graph-loader.js
+var VERSION = true ? "9.2.5" : "latest";
+var JSONGraphLoader = {
+  dataType: null,
+  batchType: null,
+  name: "DOT Graph",
+  id: "dot-graph",
+  module: "graph-layers",
+  version: VERSION,
+  worker: false,
+  extensions: ["json"],
+  mimeTypes: ["application/json"],
+  text: true,
+  options: {
+    jsongraph: {}
+  },
+  parse: async (arrayBuffer, options) => {
+    const text = new TextDecoder().decode(arrayBuffer);
+    return Promise.resolve(JSONGraphLoader.parseTextSync(text, options));
+  },
+  parseTextSync: (text, options) => {
+    throw new Error("JSONGraphLoader.parseTextSync not implemented");
+  }
+};
+
 // dist/loaders/dot-graph-loader.js
-var VERSION2 = true ? "9.2.0-beta.6" : "latest";
+var VERSION2 = true ? "9.2.5" : "latest";
 var DOTGraphLoader = {
   dataType: null,
   batchType: null,
@@ -8410,7 +8514,11 @@ var DOTParser = class {
       graphAttributes: {}
     };
     this.scopes.push(context);
-    this.result.subgraphs.set(subgraphId, { id: subgraphId, attributes: context.graphAttributes, parentId });
+    this.result.subgraphs.set(subgraphId, {
+      id: subgraphId,
+      attributes: context.graphAttributes,
+      parentId
+    });
     let shouldContinue = true;
     while (shouldContinue) {
       if (this.match("rbrace")) {