@deck.gl-community/graph-layers 9.1.1 → 9.2.0-beta.3

package/src/graph/functions/convert-plain-graph-to-arrow-graph.ts.disabled

@@ -0,0 +1,119 @@
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {ArrowGraph} from '../arrow-graph';
+import type {ArrowGraphDataBuilderOptions} from '../../graph-data/arrow-graph-data-builder';
+import {ArrowGraphDataBuilder} from '../../graph-data/arrow-graph-data-builder';
+import type {TabularGraph, TabularNode, TabularEdge} from '../tabular-graph';
+
+const NODE_ATTRIBUTE_KEYS_TO_REMOVE = [
+  'id',
+  'state',
+  'selectable',
+  'highlightConnectedEdges',
+  'label',
+  'weight'
+] as const;
+
+const EDGE_ATTRIBUTE_KEYS_TO_REMOVE = [
+  'id',
+  'sourceId',
+  'targetId',
+  'directed',
+  'state',
+  'label',
+  'weight'
+] as const;
+
+type SanitizedNodeData = {
+  label?: string;
+  weight?: number;
+  attributes: Record<string, unknown>;
+};
+
+type SanitizedEdgeData = {
+  label?: string;
+  weight?: number;
+  attributes: Record<string, unknown>;
+};
+
+export type ConvertTabularGraphToArrowGraphOptions = ArrowGraphDataBuilderOptions;
+
+export function convertTabularGraphToArrowGraph(
+  tabularGraph: TabularGraph,
+  options?: ConvertTabularGraphToArrowGraphOptions
+): ArrowGraph {
+  const builder = new ArrowGraphDataBuilder({
+    ...options,
+    version: options?.version ?? tabularGraph.version
+  });
+
+  for (const node of tabularGraph.getNodes() as Iterable<TabularNode>) {
+    const {label, weight, attributes} = sanitizeNodeData(
+      tabularGraph.getNodeDataByIndex(node.index)
+    );
+
+    builder.addNode({
+      id: node.getId(),
+      state: node.getState(),
+      selectable: node.isSelectable(),
+      highlightConnectedEdges: node.shouldHighlightConnectedEdges(),
+      label,
+      weight,
+      attributes
+    });
+  }
+
+  for (const edge of tabularGraph.getEdges() as Iterable<TabularEdge>) {
+    const {label, weight, attributes} = sanitizeEdgeData(
+      tabularGraph.getEdgeDataByIndex(edge.index)
+    );
+
+    builder.addEdge({
+      id: edge.getId(),
+      sourceId: edge.getSourceNodeId(),
+      targetId: edge.getTargetNodeId(),
+      directed: edge.isDirected(),
+      state: edge.getState(),
+      label,
+      weight,
+      attributes
+    });
+  }
+
+  return new ArrowGraph({...tabularGraph.props, data: builder.finish()});
+}
+
+function sanitizeNodeData(data: Record<string, unknown>): SanitizedNodeData {
+  const rawLabel = data.label;
+  const label = typeof rawLabel === 'string' ? rawLabel : undefined;
+  const rawWeight = data.weight;
+  const weight = typeof rawWeight === 'number' ? rawWeight : undefined;
+  const attributes = pruneAttributes(data, NODE_ATTRIBUTE_KEYS_TO_REMOVE);
+
+  return {label, weight, attributes};
+}
+
+function sanitizeEdgeData(data: Record<string, unknown>): SanitizedEdgeData {
+  const rawLabel = data.label;
+  const label = typeof rawLabel === 'string' ? rawLabel : undefined;
+  const rawWeight = data.weight;
+  const weight = typeof rawWeight === 'number' ? rawWeight : undefined;
+  const attributes = pruneAttributes(data, EDGE_ATTRIBUTE_KEYS_TO_REMOVE);
+
+  return {label, weight, attributes};
+}
+
+function pruneAttributes(
+  source: Record<string, unknown>,
+  keysToRemove: readonly string[]
+): Record<string, unknown> {
+  const attributes = {...source};
+  for (const key of keysToRemove) {
+    if (key in attributes) {
+      delete attributes[key];
+    }
+  }
+  return attributes;
+}

package/src/graph/functions/create-graph-from-data.ts

@@ -0,0 +1,16 @@
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Graph, GraphProps} from '../graph';
+import  {type GraphData, isArrowGraphData} from '../../graph-data/graph-data';
+import {ArrowGraph} from '../arrow-graph';
+import {ClassicGraph} from '../classic-graph';
+
+export function createGraphFromData(data: GraphData, props: GraphProps = {}): Graph {
+  if (isArrowGraphData(data)) {
+    return new ArrowGraph({...props, data});
+  }
+
+ return new ClassicGraph({...props, data});
+}

package/src/graph/functions/create-plain-graph-from-data.ts.disabled

@@ -0,0 +1,176 @@
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {NodeState, EdgeState} from '../core/constants';
+import type {PlainGraphData} from '../graph-data/graph-data';
+import {PlainGraphDataBuilder} from '../graph-data/plain-graph-data-builder';
+import {
+  normalizeBooleanColumn,
+  normalizeDataColumn,
+  normalizeEdgeStateColumn,
+  normalizeNodeStateColumn,
+  normalizeVersion
+} from './graph-normalization';
+import type {
+  TabularGraphSource,
+  TabularNodeAccessors,
+  TabularEdgeAccessors
+} from './tabular-graph';
+import {TabularGraph} from './tabular-graph';
+
+export function createTabularGraphFromData(data: PlainGraphData): TabularGraph {
+  const builder = new PlainGraphDataBuilder({
+    // @ts-expect-error TODO: fixme
+    nodeCapacity: Array.isArray(data.nodes) ? data.nodes.length : 0,
+    edgeCapacity: Array.isArray(data.edges) ? data.edges.length : 0,
+    version: data.version
+  });
+
+  if (Array.isArray(data.nodes)) {
+    for (const node of data.nodes) {
+      builder.addNode(node);
+    }
+  }
+
+  if (Array.isArray(data.edges)) {
+    for (const edge of data.edges) {
+      builder.addEdge(edge);
+    }
+  }
+
+  return createTabularGraphFromColumnarData(builder.build());
+}
+
+type NodeHandle = number;
+type EdgeHandle = number;
+
+type NormalizedNodeColumns = {
+  id: (string | number)[];
+  state: NodeState[];
+  selectable: boolean[];
+  highlightConnectedEdges: boolean[];
+  data: Record<string, unknown>[];
+};
+
+type NormalizedEdgeColumns = {
+  id: (string | number)[];
+  sourceId: (string | number)[];
+  targetId: (string | number)[];
+  directed: boolean[];
+  state: EdgeState[];
+  data: Record<string, unknown>[];
+};
+
+function createTabularGraphFromColumnarData(data: ColumnarGraphColumns): TabularGraph {
+  const version = normalizeVersion(data.version);
+  const nodes = normalizeNodeColumns(data.nodes);
+  const edges = normalizeEdgeColumns(data.edges);
+
+  const nodeCount = nodes.id.length;
+  const edgeCount = edges.id.length;
+
+  const nodeHandles = createIndexArray(nodeCount);
+  const edgeHandles = createIndexArray(edgeCount);
+
+  const nodeIndexById = new Map<string | number, NodeHandle>();
+  for (let i = 0; i < nodeCount; i++) {
+    nodeIndexById.set(nodes.id[i], i);
+  }
+
+  const nodeAccessors: TabularNodeAccessors<NodeHandle> = {
+    getId: (handle) => nodes.id[handle],
+    getState: (handle) => nodes.state[handle],
+    setState: (handle, state) => {
+      nodes.state[handle] = state;
+    },
+    isSelectable: (handle) => nodes.selectable[handle],
+    shouldHighlightConnectedEdges: (handle) => nodes.highlightConnectedEdges[handle],
+    getPropertyValue: (handle, key) => nodes.data[handle]?.[key],
+    setData: (handle, value) => {
+      nodes.data[handle] = {...value};
+    },
+    setDataProperty: (handle, key, value) => {
+      const record = nodes.data[handle] ?? {};
+      record[key] = value;
+      nodes.data[handle] = record;
+    },
+    getData: (handle) => nodes.data[handle]
+  };
+
+  const edgeAccessors: TabularEdgeAccessors<EdgeHandle> = {
+    getId: (handle) => edges.id[handle],
+    getSourceId: (handle) => edges.sourceId[handle],
+    getTargetId: (handle) => edges.targetId[handle],
+    isDirected: (handle) => edges.directed[handle],
+    getState: (handle) => edges.state[handle],
+    setState: (handle, state) => {
+      edges.state[handle] = state;
+    },
+    getPropertyValue: (handle, key) => edges.data[handle]?.[key],
+    setData: (handle, value) => {
+      edges.data[handle] = {...value};
+    },
+    setDataProperty: (handle, key, value) => {
+      const record = edges.data[handle] ?? {};
+      record[key] = value;
+      edges.data[handle] = record;
+    },
+    getData: (handle) => edges.data[handle]
+  };
+
+  const accessors = {node: nodeAccessors, edge: edgeAccessors};
+
+  const source: TabularGraphSource<NodeHandle, EdgeHandle> = {
+    version,
+    getNodes: () => nodeHandles,
+    getEdges: () => edgeHandles,
+    getAccessors: () => accessors,
+    findNodeById: (id) => nodeIndexById.get(id)
+  };
+
+  return new TabularGraph(source);
+}
+
+function normalizeNodeColumns(columns: ColumnarGraphNodeColumns): NormalizedNodeColumns {
+  const id = Array.isArray(columns.id) ? columns.id.slice() : [];
+  const length = id.length;
+
+  return {
+    id,
+    state: normalizeNodeStateColumn(columns.state, length),
+    selectable: normalizeBooleanColumn(columns.selectable, length, false),
+    highlightConnectedEdges: normalizeBooleanColumn(columns.highlightConnectedEdges, length, false),
+    data: normalizeDataColumn(columns.data, length)
+  };
+}
+
+function normalizeEdgeColumns(columns: ColumnarGraphEdgeColumns): NormalizedEdgeColumns {
+  const id = Array.isArray(columns.id) ? columns.id.slice() : [];
+  const length = id.length;
+
+  if (!Array.isArray(columns.sourceId) || columns.sourceId.length !== length) {
+    throw new Error('Columnar graph edge data requires a sourceId column matching the id column length.');
+  }
+
+  if (!Array.isArray(columns.targetId) || columns.targetId.length !== length) {
+    throw new Error('Columnar graph edge data requires a targetId column matching the id column length.');
+  }
+
+  return {
+    id,
+    sourceId: columns.sourceId.slice(0, length),
+    targetId: columns.targetId.slice(0, length),
+    directed: normalizeBooleanColumn(columns.directed, length, false),
+    state: normalizeEdgeStateColumn(columns.state, length),
+    data: normalizeDataColumn(columns.data, length)
+  };
+}
+
+function createIndexArray(length: number): number[] {
+  const handles: number[] = new Array(length);
+  for (let i = 0; i < length; i++) {
+    handles[i] = i;
+  }
+  return handles;
+}

package/src/graph/graph-normalization.ts

@@ -0,0 +1,87 @@
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {NodeState, EdgeState} from '../core/constants';
+
+const NODE_STATES: ReadonlySet<NodeState> = new Set(['default', 'hover', 'dragging', 'selected']);
+const EDGE_STATES: ReadonlySet<EdgeState> = new Set(['default', 'hover', 'dragging', 'selected']);
+
+export function normalizeNodeState(state: NodeState | undefined): NodeState {
+  if (state && NODE_STATES.has(state)) {
+    return state;
+  }
+  return 'default';
+}
+
+export function normalizeEdgeState(state: EdgeState | undefined): EdgeState {
+  if (state && EDGE_STATES.has(state)) {
+    return state;
+  }
+  return 'default';
+}
+
+export function normalizeNodeStateColumn(source: NodeState[] | undefined, length: number): NodeState[] {
+  const result: NodeState[] = new Array(length);
+  for (let i = 0; i < length; i++) {
+    result[i] = normalizeNodeState(source?.[i]);
+  }
+  return result;
+}
+
+export function normalizeEdgeStateColumn(source: EdgeState[] | undefined, length: number): EdgeState[] {
+  const result: EdgeState[] = new Array(length);
+  for (let i = 0; i < length; i++) {
+    result[i] = normalizeEdgeState(source?.[i]);
+  }
+  return result;
+}
+
+export function normalizeBooleanColumn(
+  source: boolean[] | undefined,
+  length: number,
+  fallback: boolean
+): boolean[] {
+  const result: boolean[] = new Array(length);
+  for (let i = 0; i < length; i++) {
+    const candidate = source?.[i];
+    result[i] = typeof candidate === 'boolean' ? candidate : fallback;
+  }
+  return result;
+}
+
+export function normalizeDataColumn(
+  source: Record<string, unknown>[] | undefined,
+  length: number
+): Record<string, unknown>[] {
+  const result: Record<string, unknown>[] = new Array(length);
+  for (let i = 0; i < length; i++) {
+    result[i] = cloneRecord(source?.[i]);
+  }
+  return result;
+}
+
+export function normalizeVersion(version: unknown): number {
+  if (typeof version === 'number' && Number.isFinite(version)) {
+    return version;
+  }
+  return 0;
+}
+
+export function cloneRecord(value: unknown): Record<string, unknown> {
+  if (value && typeof value === 'object') {
+    return {...(value as Record<string, unknown>)};
+  }
+  return {};
+}
+
+export function cloneDataColumn(
+  source: Record<string, unknown>[],
+  length: number
+): Record<string, unknown>[] {
+  const result: Record<string, unknown>[] = new Array(length);
+  for (let i = 0; i < length; i++) {
+    result[i] = cloneRecord(source[i]);
+  }
+  return result;
+}