@truedat/dd 8.14.0 → 8.14.1

package/src/utils/lineageGraph.js

@@ -1002,6 +1002,21 @@ export const lineageNodeContentWidth = (resources = []) => {
   );
 };
 
+const lineageSiblingWidths = (nodes, parentFor) => {
+  const widths = new Map();
+  nodes.forEach((node) => {
+    const parent = parentFor(node);
+    widths.set(
+      parent,
+      Math.max(widths.get(parent) || 0, lineageNodeContentWidth([node])),
+    );
+  });
+  return (node) => widths.get(parentFor(node)) || LINEAGE_NODE_WIDTH_MIN;
+};
+
+const resolvedLineageNodeWidth = (nodeWidth, node) =>
+  typeof nodeWidth === "function" ? nodeWidth(node) : nodeWidth;
+
 const lineagePath = (node, system, schema) => {
   const path = node.path || node.ancestry || node.parents || node.parent_path;
   const pathItems = Array.isArray(path)
@@ -1090,7 +1105,9 @@ const lineageNode =
     const systemType = lineageSystemType(node);
     const entity = lineageEntityPresentation(node, resolvedKind);
     const path = redesigned ? lineagePath(node, system, schema) : [];
-    const width = redesigned ? nodeWidth || NODE_WIDTH_REDESIGNED : NODE_WIDTH;
+    const width = redesigned
+      ? resolvedLineageNodeWidth(nodeWidth, node) || NODE_WIDTH_REDESIGNED
+      : NODE_WIDTH;
 
     return {
       id,
@@ -1334,8 +1351,16 @@ const lineagePositionedResourceNode =
 export const lineageTopologyNodes = (
   topology,
   nodeDesign = "redesigned",
-  nodeWidth = NODE_WIDTH_REDESIGNED,
+  nodeWidth,
 ) => {
+  const widthFor =
+    nodeWidth ??
+    (nodeDesign === "redesigned"
+      ? lineageSiblingWidths(
+          topology.nodes.filter((node) => !node.container),
+          (node) => node.parentId,
+        )
+      : NODE_WIDTH_REDESIGNED);
   const parentByNode = new Map();
   const childCountsByCanonicalId = new Map();
   const nodeById = new Map(topology.nodes.map((node) => [node.id, node]));
@@ -1345,7 +1370,7 @@ export const lineageTopologyNodes = (
     geometryById.set(node.id, {
       x: 0,
       y: 0,
-      w: nodeWidth,
+      w: resolvedLineageNodeWidth(widthFor, node),
       h: COLLAPSED_GROUP_HEIGHT,
     });
     if (!node.parentId) return;
@@ -1376,7 +1401,7 @@ export const lineageTopologyNodes = (
     resolveSystemType,
     new Set(),
     undefined,
-    nodeWidth,
+    widthFor,
   );
   return [...topology.nodes]
     .sort((a, b) => a.z - b.z || a.id.localeCompare(b.id))
@@ -2487,13 +2512,18 @@ export const lineagePositionedLayoutNodes = ({
   preparedHierarchy = preparePositionedLineageHierarchy(groups, resources),
 }) => {
   const { containerGroups, leafGroups, parentByNode } = preparedHierarchy;
+  const widthFor =
+    nodeWidth ??
+    lineageSiblingWidths([...resources, ...leafGroups], (node) =>
+      parentByNode.get(node),
+    );
   const leafGroupIds = new Set(leafGroups.map(nodeId));
   const positionedResourceGeometry = (node) =>
     positionedNodeGeometryForDesign(
       node,
       nodeDesign,
       leafGroupIds.has(nodeId(node)) ? "group" : "resource",
-      nodeWidth,
+      widthFor,
     );
   const geometryById = buildPositionedGeometryMap(
     containerGroups,
@@ -2529,7 +2559,7 @@ export const lineagePositionedLayoutNodes = ({
             resolveSystemType,
             expandedFieldNodeIds,
             onToggleFields,
-            nodeWidth,
+            widthFor,
           ),
         ),
         ...resources.map(
@@ -2543,7 +2573,7 @@ export const lineagePositionedLayoutNodes = ({
             resolveSystemType,
             expandedFieldNodeIds,
             onToggleFields,
-            nodeWidth,
+            widthFor,
           ),
         ),
       ]),
@@ -2717,7 +2747,7 @@ export const bundleLineageEdges = (edges = []) => {
   const endpointKey = (nodeId, handleId) => `${nodeId}::${handleId || ""}`;
 
   edges.forEach((edge) => {
-    if (edge.data?.containment) return;
+    if (edge.data?.containment || edge.data?.internalOwnerId) return;
 
     const sourceKey = endpointKey(edge.source, edge.sourceHandle);
     const targetKey = endpointKey(edge.target, edge.targetHandle);
@@ -2727,7 +2757,7 @@ export const bundleLineageEdges = (edges = []) => {
   });
 
   return edges.map((edge) => {
-    if (edge.data?.containment) return edge;
+    if (edge.data?.containment || edge.data?.internalOwnerId) return edge;
 
     const sourceCount =
       sourceCounts.get(endpointKey(edge.source, edge.sourceHandle)) || 0;
@@ -2754,8 +2784,11 @@ export const redesignedLineageEdges = (edges = []) =>
       data: {
         ...edge.data,
         edgeCurvature: 0.32,
-        edgePath: "bezier",
-        routeGuide: edge.data?.topology ? edge.data.routeGuide : undefined,
+        edgePath: edge.data?.internalOwnerId ? "guided-bezier" : "bezier",
+        routeGuide:
+          edge.data?.internalOwnerId || edge.data?.topology
+            ? edge.data.routeGuide
+            : undefined,
       },
     })),
   );
@@ -3114,6 +3147,18 @@ export const planLineageEdgeRoutes = (edges = [], nodes = []) => {
   }));
 };
 
+export const planExternalLineageEdgeRoutes = (edges = [], nodes = []) => {
+  const plannedById = new Map(
+    planLineageEdgeRoutes(
+      edges.filter((edge) => !edge.data?.internalOwnerId),
+      nodes,
+    ).map((edge) => [edge.id, edge]),
+  );
+  return edges.map((edge) =>
+    edge.data?.internalOwnerId ? edge : plannedById.get(edge.id),
+  );
+};
+
 export const focusedLineageGraph = (selectedNodeId, edges = []) => {
   const focusedNodeIds = new Set();
   const focusedEdgeIds = new Set();

package/src/utils/lineageInternalRoutes.js

@@ -0,0 +1,389 @@
+const LINEAGE_PREVIEW_EDGE_Z_INDEX = 150;
+
+const HEADER = 58;
+const PADDING = 16;
+const COLUMN_GAP = 152;
+const PORT = 24;
+const PITCH = 12;
+
+const assignSlots = (items) => {
+  const ends = [];
+  const slots = new Map();
+  [...items]
+    .sort(
+      (a, b) => a.start - b.start || a.end - b.end || a.id.localeCompare(b.id),
+    )
+    .forEach(({ id, start, end }) => {
+      const available = ends.findIndex((last) => last < start);
+      const slot = available < 0 ? ends.length : available;
+      ends.splice(slot, 1, end);
+      slots.set(id, slot);
+    });
+  return { slots, count: ends.length };
+};
+
+export const internalRoleColumns = (children, edges) => {
+  const incoming = new Set(edges.map(({ target }) => target));
+  const outgoing = new Set(edges.map(({ source }) => source));
+  const groups = { entry: [], intermediate: [], exit: [], independent: [] };
+  children.forEach((node) => {
+    const role = incoming.has(node.id)
+      ? outgoing.has(node.id)
+        ? "intermediate"
+        : "exit"
+      : outgoing.has(node.id)
+        ? "entry"
+        : "independent";
+    groups[role].push({ ...node, role });
+  });
+  const columns = ["entry", "intermediate", "exit"]
+    .filter((key) => groups[key].length)
+    .map((key) => ({ key, nodes: groups[key] }));
+  if (groups.independent.length) {
+    if (!columns.length) columns.push({ key: "independent", nodes: [] });
+    columns[0].nodes.push(...groups.independent);
+  }
+  return columns;
+};
+
+export const reserveInternalGroupChannels = ({
+  columns,
+  edges,
+  nodeGap = 44,
+  columnGap = COLUMN_GAP,
+  columnLabelHeight = 0,
+  compact = false,
+}) => {
+  const lanePitch = compact ? 4 : PITCH;
+  const laneOffset = compact ? 32 : 48;
+  const lanePadding = compact ? 48 : 72;
+  const labelTop = HEADER + (columnLabelHeight ? 8 : 0);
+  const indexed = new Map();
+  const widths = columns.map(({ nodes }) =>
+    Math.max(...nodes.map(({ width }) => width)),
+  );
+  const columnEnds = columns.map(({ nodes, sectioned }, column) => {
+    const end = nodes.reduce(
+      (y, node, index) => {
+        const sectionStart =
+          index > 0 &&
+          node.role !== nodes[index - 1].role &&
+          (sectioned || node.role === "independent");
+        const top = y + (sectionStart ? 32 : 0);
+        indexed.set(node.id, { ...node, column, y: top, sectionStart });
+        return top + node.height + nodeGap;
+      },
+      labelTop + columnLabelHeight + (sectioned ? 8 : 0),
+    );
+    return end - nodeGap;
+  });
+  const bodyBottom = Math.max(...columnEnds);
+  const validEdges = edges.filter(
+    (e) =>
+      !e.data?.containment &&
+      e.source !== e.target &&
+      indexed.has(e.source) &&
+      indexed.has(e.target),
+  );
+  const routes = [...validEdges]
+    .sort(
+      (a, b) =>
+        a.source.localeCompare(b.source) ||
+        a.target.localeCompare(b.target) ||
+        String(a.id || "").localeCompare(String(b.id || "")),
+    )
+    .map((edge, index) => {
+      const source = indexed.get(edge.source),
+        target = indexed.get(edge.target);
+      const sourceY = source.y + source.height / 2,
+        targetY = target.y + target.height / 2;
+      const sameColumn = source.column === target.column;
+      const corridor = sameColumn || target.column === source.column + 1;
+      const topDistance =
+        sourceY + targetY - 2 * (labelTop + columnLabelHeight);
+      const bottomDistance = 2 * bodyBottom - sourceY - targetY;
+      return {
+        edge,
+        id: edge.id || `${edge.source}->${edge.target}:${index}`,
+        source,
+        target,
+        sourceY,
+        targetY,
+        sameColumn,
+        corridor,
+        side: topDistance <= bottomDistance ? "top" : "bottom",
+      };
+    });
+  const boundaryItems = new Map();
+  const buses = { top: [], bottom: [] };
+  const addBoundary = (boundary, id, a, b) => {
+    const items = boundaryItems.get(boundary) || [];
+    items.push({ id, start: Math.min(a, b), end: Math.max(a, b) });
+    boundaryItems.set(boundary, items);
+  };
+  routes.forEach((r) => {
+    if (r.corridor) addBoundary(r.source.column, r.id, r.sourceY, r.targetY);
+    else {
+      const limit = r.side === "top" ? -Infinity : Infinity;
+      addBoundary(r.source.column, `${r.id}:source`, r.sourceY, limit);
+      addBoundary(r.target.column - 1, `${r.id}:target`, r.targetY, limit);
+      buses[r.side].push({
+        id: r.id,
+        start: Math.min(r.source.column, r.target.column - 1),
+        end: Math.max(r.source.column, r.target.column - 1),
+      });
+    }
+  });
+  const boundarySlots = new Map(
+    [...boundaryItems].map(([key, items]) => [key, assignSlots(items)]),
+  );
+  const busSlots = {
+    top: assignSlots(buses.top),
+    bottom: assignSlots(buses.bottom),
+  };
+  const topReserve = busSlots.top.count ? 36 + busSlots.top.count * PITCH : 0;
+  const bottomReserve = busSlots.bottom.count
+    ? 36 + busSlots.bottom.count * PITCH
+    : 12;
+  const boundaryWidth = (index) =>
+    Math.max(
+      columnGap,
+      lanePadding + (boundarySlots.get(index)?.count || 0) * lanePitch,
+    );
+  const outsideWidth = (index) =>
+    boundarySlots.has(index)
+      ? lanePadding + boundarySlots.get(index).count * lanePitch
+      : PADDING;
+  const positions = [];
+  columns.forEach((_column, index) => {
+    positions.push(
+      index
+        ? positions[index - 1] + widths[index - 1] + boundaryWidth(index - 1)
+        : outsideWidth(-1),
+    );
+  });
+  const geometries = new Map(
+    [...indexed].map(([id, n]) => [
+      id,
+      { x: positions[n.column], y: n.y + topReserve, w: n.width, h: n.height },
+    ]),
+  );
+  const boundaryX = (index, id) => {
+    const start = index < 0 ? 0 : positions[index] + widths[index];
+    return (
+      start + laneOffset + boundarySlots.get(index).slots.get(id) * lanePitch
+    );
+  };
+  const guidesByEdgeId = new Map();
+  routes.forEach((r) => {
+    const source = geometries.get(r.edge.source),
+      target = geometries.get(r.edge.target);
+    const sourceY = source.y + source.h / 2,
+      targetY = target.y + target.h / 2;
+    const sourceStubX =
+      positions[r.source.column] + widths[r.source.column] + PORT;
+    const targetStubX = r.sameColumn
+      ? positions[r.target.column] + widths[r.target.column] + PORT
+      : target.x - PORT;
+    const guide = {
+      sourceStubX,
+      targetStubX,
+      sourcePortPosition: "right",
+      targetPortPosition: r.sameColumn ? "right" : "left",
+      cornerRadius: 24,
+    };
+    if (r.corridor) {
+      const laneX = boundaryX(r.source.column, r.id);
+      guidesByEdgeId.set(r.id, {
+        ...guide,
+        kind: "corridor",
+        laneX,
+        labelPoint: {
+          x: (sourceStubX + 6 * laneX + targetStubX) / 8,
+          y: (sourceY + targetY) / 2,
+        },
+      });
+    } else {
+      const laneY =
+        r.side === "top"
+          ? labelTop +
+            columnLabelHeight +
+            12 +
+            busSlots.top.slots.get(r.id) * PITCH
+          : bodyBottom +
+            topReserve +
+            24 +
+            busSlots.bottom.slots.get(r.id) * PITCH;
+      const sourceLaneX = boundaryX(r.source.column, `${r.id}:source`);
+      const targetLaneX = boundaryX(r.target.column - 1, `${r.id}:target`);
+      guidesByEdgeId.set(r.id, {
+        ...guide,
+        kind: "bypass",
+        sourceLaneX,
+        targetLaneX,
+        laneY,
+        labelPoint: { x: (sourceLaneX + targetLaneX) / 2, y: laneY },
+      });
+    }
+  });
+  const labels = columnLabelHeight
+    ? columns.map((column, index) => ({
+        key: column.key,
+        roles: column.roles,
+        x: positions[index],
+        y: labelTop,
+        width: widths[index],
+        count: column.roles
+          ? column.nodes.length
+          : column.nodes.filter((n) => n.role === column.key).length,
+      }))
+    : [];
+  indexed.forEach((n) => {
+    if (n.sectionStart)
+      labels.push({
+        key: n.role,
+        x: positions[n.column],
+        y: n.y + topReserve - 32,
+        width: widths[n.column],
+        count: columns[n.column].nodes.filter((item) => item.role === n.role)
+          .length,
+      });
+  });
+  return {
+    width:
+      positions[positions.length - 1] +
+      widths[widths.length - 1] +
+      outsideWidth(columns.length - 1),
+    height: bodyBottom + topReserve + bottomReserve,
+    geometries,
+    guidesByEdgeId: Object.fromEntries(guidesByEdgeId),
+    columns: labels,
+  };
+};
+
+export const layoutInternalGroup = ({
+  children,
+  rankById,
+  edges,
+  dependencyLayout,
+}) => {
+  const rankedColumns = new Map();
+  children.forEach((child) => {
+    const rank = rankById.get(child.id) || 0;
+    const column = rankedColumns.get(rank) || [];
+    column.push(child);
+    rankedColumns.set(rank, column);
+  });
+  const compact = dependencyLayout === "compact";
+  const roleColumns = internalRoleColumns(children, edges);
+  const rolesById = new Map(
+    roleColumns.flatMap(({ nodes }) => nodes.map(({ id, role }) => [id, role])),
+  );
+  const columns = compact
+    ? [
+        {
+          key: roleColumns[0].key,
+          sectioned: true,
+          nodes: roleColumns.flatMap(({ nodes }) => nodes),
+        },
+      ]
+    : [...rankedColumns].map(([rank, nodes]) => ({
+        rank,
+        key: `rank-${rank}`,
+        roles: [...new Set(nodes.map(({ id }) => rolesById.get(id)))],
+        nodes,
+      }));
+  return reserveInternalGroupChannels({
+    columns,
+    edges,
+    nodeGap: compact ? 12 : 8,
+    columnGap: compact ? 136 : 120,
+    columnLabelHeight: 24,
+    compact,
+  });
+};
+
+export const applyInternalNodeLayers = (nodes = []) => {
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const depths = new Map();
+  const depth = (id, visited = new Set()) => {
+    if (depths.has(id)) return depths.get(id);
+    const node = byId.get(id);
+    if (!node?.parentId || !byId.has(node.parentId) || visited.has(id))
+      return 0;
+    const value = 1 + depth(node.parentId, new Set([...visited, id]));
+    depths.set(id, value);
+    return value;
+  };
+  return nodes.map((node) =>
+    node.type === "lineageGroup"
+      ? { ...node, zIndex: 10 + depth(node.id) }
+      : node.zIndex >= 200 ||
+          node.data?.internalEdgeGuides ||
+          byId.get(node.parentId)?.data?.internalEdgeGuides
+        ? { ...node, zIndex: 200 + 4 * depth(node.id) }
+        : node,
+  );
+};
+
+export const applyInternalEdgeRoutes = (edges = [], nodes = []) => {
+  const guides = new Map();
+  nodes.forEach((node) =>
+    Object.entries(node.data?.internalEdgeGuides || {}).forEach(([id, guide]) =>
+      guides.set(id, { node, guide }),
+    ),
+  );
+  return edges.map((edge) => {
+    const owned = guides.get(edge.id);
+    if (!owned) {
+      if (!edge.data?.internalOwnerId) return edge;
+      return {
+        ...edge,
+        zIndex: LINEAGE_PREVIEW_EDGE_Z_INDEX,
+        data: {
+          ...edge.data,
+          selectionBaseZIndex: 100,
+          internalOwnerId: undefined,
+          routeGuide: undefined,
+          edgePath: "bezier",
+          lockTargetPort: false,
+        },
+      };
+    }
+    const { node, guide } = owned;
+    const { x, y } = node.data.absoluteGeometry;
+    const absolute = {
+      ...guide,
+      ...Object.fromEntries(
+        ["laneX", "sourceLaneX", "targetLaneX", "sourceStubX", "targetStubX"]
+          .filter((key) => Number.isFinite(guide[key]))
+          .map((key) => [key, guide[key] + x]),
+      ),
+      ...(Number.isFinite(guide.laneY) ? { laneY: guide.laneY + y } : {}),
+      labelPoint: { x: guide.labelPoint.x + x, y: guide.labelPoint.y + y },
+    };
+    return {
+      ...edge,
+      zIndex: LINEAGE_PREVIEW_EDGE_Z_INDEX,
+      sourceHandle: "end-node",
+      targetHandle:
+        guide.targetPortPosition === "right"
+          ? "target-right-node"
+          : "start-node",
+      data: {
+        ...edge.data,
+        selectionBaseZIndex: node.zIndex + 2,
+        internalOwnerId: node.id,
+        edgePath: "guided-bezier",
+        routeGuide: absolute,
+        forceHorizontalPorts: true,
+        sourcePortPosition: guide.sourcePortPosition,
+        targetPortPosition: guide.targetPortPosition,
+        lockSourcePort: true,
+        lockTargetPort: true,
+        bundleSource: false,
+        bundleTarget: false,
+      },
+    };
+  });
+};

package/src/utils/lineageLayout.js

@@ -1,7 +1,9 @@
+import { layoutInternalGroup } from "./lineageInternalRoutes";
+
 const DEFAULT_NODE_WIDTH = 288;
 const DEFAULT_NODE_HEIGHT = 82;
-const COLUMN_GAP = 152;
-const NODE_GAP = 44;
+const COLUMN_GAP = 160;
+const NODE_GAP = 48;
 const FIELD_GAP = 4;
 const ROOT_BRANCH_GAP = 40;
 const GROUP_PADDING_X = 16;
@@ -861,7 +863,7 @@ const preserveAnchor = (geometries, previousLayout, anchorNodeId) => {
   );
 };
 
-const applyGeometries = (nodes, geometries) =>
+const applyGeometries = (nodes, geometries, internalLayouts) =>
   nodes.map((node) => {
     const geometry = geometries.get(node.id) || nodeGeometry(node);
     const parentGeometry = node.parentId ? geometries.get(node.parentId) : null;
@@ -880,6 +882,8 @@ const applyGeometries = (nodes, geometries) =>
       data: {
         ...node.data,
         absoluteGeometry: geometry,
+        internalEdgeGuides: internalLayouts.get(node.id)?.guidesByEdgeId,
+        internalColumns: internalLayouts.get(node.id)?.columns,
       },
       style: {
         ...node.style,
@@ -889,7 +893,7 @@ const applyGeometries = (nodes, geometries) =>
     };
   });
 
-const compoundGeometry = (nodes, edges) => {
+const compoundGeometry = (nodes, edges, dependencyLayout, internalLayouts) => {
   const hierarchy = buildHierarchy(nodes);
   const { nodeById, parentById, childIdsByParentId } = hierarchy;
   const ancestorsById = new Map();
@@ -946,13 +950,10 @@ const compoundGeometry = (nodes, edges) => {
         (child) => nodeById.get(child).data?.variant === "lineage-field",
       );
     const childNodes = children.map((child) => nodeById.get(child));
-    const plan = cachedTopologyPlan(
-      childNodes,
-      fields ? [] : projectedByParent.get(id) || [],
-      "compound",
-    );
+    const relations = projectedByParent.get(id) || [];
+    const plan = cachedTopologyPlan(childNodes, relations, "compound");
     const ordered = [...children].sort((a, b) => {
-      if (fields)
+      if (fields && !relations.length)
         return (
           nodeLabel(nodeById.get(a)).localeCompare(
             nodeLabel(nodeById.get(b)),
@@ -964,6 +965,23 @@ const compoundGeometry = (nodes, edges) => {
         a.localeCompare(b)
       );
     });
+    if (fields && relations.length) {
+      const block = layoutInternalGroup({
+        children: ordered.map((child) => {
+          const geometry = nodeGeometry(nodeById.get(child));
+          return { id: child, width: geometry.w, height: geometry.h };
+        }),
+        rankById: plan.rankById,
+        edges: relations,
+        dependencyLayout,
+      });
+      internalLayouts.set(id, {
+        guidesByEdgeId: block.guidesByEdgeId,
+        columns: block.columns,
+      });
+      block.geometries.set(id, { x: 0, y: 0, w: block.width, h: block.height });
+      return block;
+    }
     const columns = new Map();
     ordered.forEach((child) => {
       const rank = fields ? 0 : plan.rankById.get(child) || 0;
@@ -1030,15 +1048,17 @@ export const layoutVisibleLineageGraph = ({
   graphType = "impact",
   nodes = [],
   previousLayout = [],
+  dependencyLayout = "compact",
 }) => {
   if (!nodes.length) return [];
+  const internalLayouts = new Map();
 
   const packed = nodes.some(
     (node) =>
       node.data?.topology ||
       (node.parentId && node.data?.variant === "lineage-field"),
   )
-    ? compoundGeometry(nodes, edges)
+    ? compoundGeometry(nodes, edges, dependencyLayout, internalLayouts)
     : packedGeometry(
         nodes,
         cachedTopologyPlan(nodes, edges, graphType),
@@ -1046,5 +1066,5 @@ export const layoutVisibleLineageGraph = ({
       );
   const anchored = preserveAnchor(packed, previousLayout, anchorNodeId);
 
-  return applyGeometries(nodes, anchored);
+  return applyGeometries(nodes, anchored, internalLayouts);
 };

package/src/utils/lineageViewPreferences.js

@@ -0,0 +1,21 @@
+const KEY = "td.lineage.dependencyLayout.v1";
+export const normalizeDependencyLayout = (value) =>
+  value === "expanded" ? "expanded" : "compact";
+export const readDependencyLayout = () => {
+  try {
+    return normalizeDependencyLayout(globalThis.localStorage?.getItem(KEY));
+  } catch {
+    return "compact";
+  }
+};
+export const writeDependencyLayout = (value) => {
+  try {
+    const storage = globalThis.localStorage;
+    if (!storage) return false;
+
+    storage.setItem(KEY, normalizeDependencyLayout(value));
+    return true;
+  } catch {
+    return false;
+  }
+};