@loaders.gl/graphs 5.0.0-beta.1 → 5.0.0-beta.10

package/README.md

@@ -1,6 +1,8 @@
 # @loaders.gl/graphs
 
-Framework-independent loaders for GraphML, Graphviz DOT, and GEXF documents.
+Graph loaders for Graphviz DOT, GraphML, and GEXF.
+
+Supported formats: DOT, GraphML, GEXF.
 
 ## Graph output shapes
 
@@ -180,4 +182,4 @@ Foreign namespace extensions are ignored. See the [GEXF specification](https://g
 ## Sources and credits
 
 See [THIRD-PARTY-NOTICES.md](./THIRD-PARTY-NOTICES.md) for implementation lineage
-and applicable notices, and the project-wide [References and credits](https://loaders.gl/docs/references-and-credits).
+and applicable notices, and the project-wide [Attributions and Credits](https://loaders.gl/docs/references-and-credits).

package/THIRD-PARTY-NOTICES.md

@@ -1,6 +1,6 @@
 # @loaders.gl/graphs: sources and credits
 
-Graph loaders are developed by vis.gl contributors against DOT, GEXF and GraphML format definitions. Separately installed fast-xml-parser supplies XML parsing; Apache Arrow supplies columnar tables.
+Graph loaders are developed by vis.gl contributors against DOT, GEXF and GraphML format definitions. The native @loaders.gl/documents parser supplies XML parsing; Apache Arrow supplies columnar tables.
 
 ## Scope and maintenance
 

package/dist/dot-loader-types.cjs

@@ -0,0 +1,60 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/dot-loader-types.js
+var dot_loader_types_exports = {};
+__export(dot_loader_types_exports, {
+  DOTLoader: () => DOTLoader
+});
+module.exports = __toCommonJS(dot_loader_types_exports);
+var VERSION = true ? "5.0.0-beta.10" : "latest";
+async function preload() {
+  const { DOTLoaderWithParser } = await import("@loaders.gl/graphs/dot-loader");
+  return DOTLoaderWithParser;
+}
+var DOTLoader = {
+  name: "DOT",
+  id: "dot",
+  module: "graphs",
+  version: VERSION,
+  extensions: ["dot", "gv"],
+  mimeTypes: ["text/vnd.graphviz", "text/x-graphviz", "application/vnd.graphviz"],
+  text: true,
+  worker: false,
+  supportsNativeArrow: true,
+  dataType: null,
+  batchType: null,
+  options: { dot: { shape: "arrow" } },
+  preload
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DOTLoader
+});
+//# sourceMappingURL=dot-loader-types.cjs.map

package/dist/dot-loader-types.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/dot-loader-types.ts"],
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {Loader} from '@loaders.gl/core/loader-utils';\nimport type {DOTOutput} from './dot-types';\nimport type {GraphShape} from './graph-types';\n\n/** Options for selecting the DOT graph output representation. */\nexport type DOTLoaderOptions = {\n  /** Format-specific graph options. */\n  dot?: {\n    /** Representation of each named table; defaults to Arrow. */\n    shape?: GraphShape;\n  };\n};\n\n// @ts-ignore __VERSION__ is injected by the build.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\n/** Preloads the DOT parser implementation. */\nasync function preload() {\n  const {DOTLoaderWithParser} = await import('@loaders.gl/graphs/dot-loader');\n  return DOTLoaderWithParser;\n}\n\n/** Metadata-only loader for Graphviz DOT documents. */\nexport const DOTLoader = {\n  name: 'DOT',\n  id: 'dot',\n  module: 'graphs',\n  version: VERSION,\n  extensions: ['dot', 'gv'],\n  mimeTypes: ['text/vnd.graphviz', 'text/x-graphviz', 'application/vnd.graphviz'],\n  text: true,\n  worker: false,\n  supportsNativeArrow: true,\n  dataType: null as unknown as DOTOutput,\n  batchType: null as never,\n  options: {dot: {shape: 'arrow'}},\n  preload\n} as const satisfies Loader<DOTOutput, never, DOTLoaderOptions>;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;AAkBA,IAAM,UAAU,OAAoC,kBAAe;AAGnE,eAAe,UAAO;AACpB,QAAM,EAAC,oBAAmB,IAAI,MAAM,OAAO,+BAA+B;AAC1E,SAAO;AACT;AAGO,IAAM,YAAY;EACvB,MAAM;EACN,IAAI;EACJ,QAAQ;EACR,SAAS;EACT,YAAY,CAAC,OAAO,IAAI;EACxB,WAAW,CAAC,qBAAqB,mBAAmB,0BAA0B;EAC9E,MAAM;EACN,QAAQ;EACR,qBAAqB;EACrB,UAAU;EACV,WAAW;EACX,SAAS,EAAC,KAAK,EAAC,OAAO,QAAO,EAAC;EAC/B;;",
+  "names": []
+}

package/dist/dot-loader-types.d.ts

@@ -21,11 +21,12 @@ declare function preload(): Promise<{
     mimeTypes: ["text/vnd.graphviz", "text/x-graphviz", "application/vnd.graphviz"];
     text: true;
     worker: false;
+    supportsNativeArrow: true;
     dataType: DOTOutput;
     batchType: never;
     options: {
         readonly dot: {
-            readonly shape: "arrow-table";
+            readonly shape: "arrow";
         };
     };
     preload: typeof preload;
@@ -40,11 +41,12 @@ export declare const DOTLoader: {
     readonly mimeTypes: ["text/vnd.graphviz", "text/x-graphviz", "application/vnd.graphviz"];
     readonly text: true;
     readonly worker: false;
+    readonly supportsNativeArrow: true;
     readonly dataType: DOTOutput;
     readonly batchType: never;
     readonly options: {
         readonly dot: {
-            readonly shape: "arrow-table";
+            readonly shape: "arrow";
         };
     };
     readonly preload: typeof preload;

package/dist/dot-loader-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dot-loader-types.d.ts","sourceRoot":"","sources":["../src/dot-loader-types.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,SAAS,EAAC,uBAAoB;AAC3C,OAAO,KAAK,EAAC,UAAU,EAAC,yBAAsB;AAE9C,iEAAiE;AACjE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,qCAAqC;IACrC,GAAG,CAAC,EAAE;QACJ,6DAA6D;QAC7D,KAAK,CAAC,EAAE,UAAU,CAAC;KACpB,CAAC;CACH,CAAC;AAKF,8CAA8C;AAC9C,iBAAe,OAAO;;;;;;;;;;;;cAeS,SAAS;eACnB,KAAK;;;;;;;GAbzB;AAED,uDAAuD;AACvD,eAAO,MAAM,SAAS;;;;;;;;;uBASS,SAAS;wBACnB,KAAK;;;;;;;CAGqC,CAAC"}
+{"version":3,"file":"dot-loader-types.d.ts","sourceRoot":"","sources":["../src/dot-loader-types.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,SAAS,EAAC,uBAAoB;AAC3C,OAAO,KAAK,EAAC,UAAU,EAAC,yBAAsB;AAE9C,iEAAiE;AACjE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,qCAAqC;IACrC,GAAG,CAAC,EAAE;QACJ,6DAA6D;QAC7D,KAAK,CAAC,EAAE,UAAU,CAAC;KACpB,CAAC;CACH,CAAC;AAKF,8CAA8C;AAC9C,iBAAe,OAAO;;;;;;;;;;;;;cAgBS,SAAS;eACnB,KAAK;;;;;;;GAdzB;AAED,uDAAuD;AACvD,eAAO,MAAM,SAAS;;;;;;;;;;uBAUS,SAAS;wBACnB,KAAK;;;;;;;CAGqC,CAAC"}

package/dist/dot-loader-types.js

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 // @ts-ignore __VERSION__ is injected by the build.
-const VERSION = typeof "5.0.0-beta.1" !== 'undefined' ? "5.0.0-beta.1" : 'latest';
+const VERSION = typeof "5.0.0-beta.10" !== 'undefined' ? "5.0.0-beta.10" : 'latest';
 /** Preloads the DOT parser implementation. */
 async function preload() {
     const { DOTLoaderWithParser } = await import('@loaders.gl/graphs/dot-loader');
@@ -18,9 +18,10 @@ export const DOTLoader = {
     mimeTypes: ['text/vnd.graphviz', 'text/x-graphviz', 'application/vnd.graphviz'],
     text: true,
     worker: false,
+    supportsNativeArrow: true,
     dataType: null,
     batchType: null,
-    options: { dot: { shape: 'arrow-table' } },
+    options: { dot: { shape: 'arrow' } },
     preload
 };
 //# sourceMappingURL=dot-loader-types.js.map

package/dist/dot-loader-types.js.map

@@ -1 +1 @@
-{"version":3,"file":"dot-loader-types.js","sourceRoot":"","sources":["../src/dot-loader-types.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAepC,mDAAmD;AACnD,MAAM,OAAO,GAAG,qBAAkB,KAAK,WAAW,CAAC,CAAC,gBAAa,CAAC,CAAC,QAAQ,CAAC;AAE5E,8CAA8C;AAC9C,KAAK,UAAU,OAAO;IACpB,MAAM,EAAC,mBAAmB,EAAC,GAAG,MAAM,MAAM,CAAC,+BAA+B,CAAC,CAAC;IAC5E,OAAO,mBAAmB,CAAC;AAC7B,CAAC;AAED,uDAAuD;AACvD,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,IAAI,EAAE,KAAK;IACX,EAAE,EAAE,KAAK;IACT,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC;IACzB,SAAS,EAAE,CAAC,mBAAmB,EAAE,iBAAiB,EAAE,0BAA0B,CAAC;IAC/E,IAAI,EAAE,IAAI;IACV,MAAM,EAAE,KAAK;IACb,QAAQ,EAAE,IAA4B;IACtC,SAAS,EAAE,IAAa;IACxB,OAAO,EAAE,EAAC,GAAG,EAAE,EAAC,KAAK,EAAE,aAAa,EAAC,EAAC;IACtC,OAAO;CACsD,CAAC"}
+{"version":3,"file":"dot-loader-types.js","sourceRoot":"","sources":["../src/dot-loader-types.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAepC,mDAAmD;AACnD,MAAM,OAAO,GAAG,sBAAkB,KAAK,WAAW,CAAC,CAAC,iBAAa,CAAC,CAAC,QAAQ,CAAC;AAE5E,8CAA8C;AAC9C,KAAK,UAAU,OAAO;IACpB,MAAM,EAAC,mBAAmB,EAAC,GAAG,MAAM,MAAM,CAAC,+BAA+B,CAAC,CAAC;IAC5E,OAAO,mBAAmB,CAAC;AAC7B,CAAC;AAED,uDAAuD;AACvD,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,IAAI,EAAE,KAAK;IACX,EAAE,EAAE,KAAK;IACT,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC;IACzB,SAAS,EAAE,CAAC,mBAAmB,EAAE,iBAAiB,EAAE,0BAA0B,CAAC;IAC/E,IAAI,EAAE,IAAI;IACV,MAAM,EAAE,KAAK;IACb,mBAAmB,EAAE,IAAI;IACzB,QAAQ,EAAE,IAA4B;IACtC,SAAS,EAAE,IAAa;IACxB,OAAO,EAAE,EAAC,GAAG,EAAE,EAAC,KAAK,EAAE,OAAO,EAAC,EAAC;IAChC,OAAO;CACsD,CAAC"}

package/dist/dot-loader.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res, err) => function __init() {
   if (err) throw err[0];
@@ -25,14 +23,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/dot-loader-types.ts
@@ -54,288 +44,21 @@ var init_dot_loader_types = __esm({
       mimeTypes: ["text/vnd.graphviz", "text/x-graphviz", "application/vnd.graphviz"],
       text: true,
       worker: false,
+      supportsNativeArrow: true,
       dataType: null,
       batchType: null,
-      options: { dot: { shape: "arrow-table" } },
+      options: { dot: { shape: "arrow" } },
       preload
     };
   }
 });
 
-// ../core/src/schema-utils/lib/schema/convert-arrow-schema.ts
-function convertArrowToSchema(arrowSchema) {
-  return serializeArrowSchema(arrowSchema);
-}
-function serializeArrowSchema(arrowSchema) {
-  return {
-    fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
-    metadata: serializeArrowMetadata(arrowSchema.metadata)
-  };
-}
-function serializeArrowMetadata(arrowMetadata) {
-  return Object.fromEntries(arrowMetadata);
-}
-function serializeArrowField(field) {
-  return {
-    name: field.name,
-    type: serializeArrowType(field.type),
-    nullable: field.nullable,
-    metadata: serializeArrowMetadata(field.metadata)
-  };
-}
-function serializeArrowType(arrowType) {
-  if (isArrowViewType(arrowType, "BinaryView")) {
-    return "binary-view";
-  }
-  if (isArrowViewType(arrowType, "Utf8View")) {
-    return "utf8-view";
-  }
-  if (isOptionalArrowType(arrowType, "LargeList")) {
-    const largeListType = arrowType;
-    return {
-      type: "large-list",
-      children: [serializeArrowField(largeListType.valueField)]
-    };
-  }
-  switch (arrowType.constructor) {
-    case arrow.Null:
-      return "null";
-    case arrow.Binary:
-      return "binary";
-    case arrow.FixedSizeBinary:
-      return {
-        type: "fixed-size-binary",
-        byteWidth: arrowType.byteWidth
-      };
-    case arrow.Bool:
-      return "bool";
-    case arrow.Int:
-      const intType = arrowType;
-      return `${intType.isSigned ? "" : "u"}int${intType.bitWidth}`;
-    case arrow.Int8:
-      return "int8";
-    case arrow.Int16:
-      return "int16";
-    case arrow.Int32:
-      return "int32";
-    case arrow.Int64:
-      return "int64";
-    case arrow.Uint8:
-      return "uint8";
-    case arrow.Uint16:
-      return "uint16";
-    case arrow.Uint32:
-      return "uint32";
-    case arrow.Uint64:
-      return "uint64";
-    case arrow.Float:
-      const precision = arrowType.precision;
-      switch (precision) {
-        case arrow.Precision.HALF:
-          return "float16";
-        case arrow.Precision.SINGLE:
-          return "float32";
-        case arrow.Precision.DOUBLE:
-          return "float64";
-        default:
-          return "float16";
-      }
-    case arrow.Float16:
-      return "float16";
-    case arrow.Float32:
-      return "float32";
-    case arrow.Float64:
-      return "float64";
-    case arrow.Utf8:
-      return "utf8";
-    case arrow.Decimal:
-      const decimal = arrowType;
-      return {
-        type: "decimal",
-        bitWidth: decimal.bitWidth,
-        precision: decimal.precision,
-        scale: decimal.scale
-      };
-    case arrow.Date_:
-      const dateUnit = arrowType.unit;
-      return dateUnit === arrow.DateUnit.DAY ? "date-day" : "date-millisecond";
-    case arrow.DateDay:
-      return "date-day";
-    case arrow.DateMillisecond:
-      return "date-millisecond";
-    case arrow.Time:
-      const timeUnit = arrowType.unit;
-      switch (timeUnit) {
-        case arrow.TimeUnit.SECOND:
-          return "time-second";
-        case arrow.TimeUnit.MILLISECOND:
-          return "time-millisecond";
-        case arrow.TimeUnit.MICROSECOND:
-          return "time-microsecond";
-        case arrow.TimeUnit.NANOSECOND:
-          return "time-nanosecond";
-        default:
-          return "time-second";
-      }
-    case arrow.TimeMillisecond:
-      return "time-millisecond";
-    case arrow.TimeSecond:
-      return "time-second";
-    case arrow.TimeMicrosecond:
-      return "time-microsecond";
-    case arrow.TimeNanosecond:
-      return "time-nanosecond";
-    case arrow.Timestamp:
-      const timeStampUnit = arrowType.unit;
-      switch (timeStampUnit) {
-        case arrow.TimeUnit.SECOND:
-          return "timestamp-second";
-        case arrow.TimeUnit.MILLISECOND:
-          return "timestamp-millisecond";
-        case arrow.TimeUnit.MICROSECOND:
-          return "timestamp-microsecond";
-        case arrow.TimeUnit.NANOSECOND:
-          return "timestamp-nanosecond";
-        default:
-          return "timestamp-second";
-      }
-    case arrow.TimestampSecond:
-      return "timestamp-second";
-    case arrow.TimestampMillisecond:
-      return "timestamp-millisecond";
-    case arrow.TimestampMicrosecond:
-      return "timestamp-microsecond";
-    case arrow.TimestampNanosecond:
-      return "timestamp-nanosecond";
-    case arrow.Interval:
-      const intervalUnit = arrowType.unit;
-      switch (intervalUnit) {
-        case arrow.IntervalUnit.DAY_TIME:
-          return "interval-daytime";
-        case arrow.IntervalUnit.YEAR_MONTH:
-          return "interval-yearmonth";
-        default:
-          return "interval-daytime";
-      }
-    case arrow.IntervalDayTime:
-      return "interval-daytime";
-    case arrow.IntervalYearMonth:
-      return "interval-yearmonth";
-    case arrow.Map_:
-      const mapType = arrowType;
-      return {
-        type: "map",
-        keysSorted: mapType.keysSorted,
-        children: mapType.children.map((arrowField) => serializeArrowField(arrowField))
-      };
-    case arrow.List:
-      const listType = arrowType;
-      const listField = listType.valueField;
-      return {
-        type: "list",
-        children: [serializeArrowField(listField)]
-      };
-    case arrow.FixedSizeList:
-      const fixedSizeList = arrowType;
-      return {
-        type: "fixed-size-list",
-        listSize: fixedSizeList.listSize,
-        children: [serializeArrowField(fixedSizeList.children[0])]
-      };
-    case arrow.Struct:
-      const structType = arrowType;
-      return {
-        type: "struct",
-        children: structType.children.map((arrowField) => serializeArrowField(arrowField))
-      };
-    case arrow.SparseUnion:
-    case arrow.DenseUnion:
-      const unionType = arrowType;
-      return {
-        type: unionType instanceof arrow.DenseUnion ? "dense-union" : "sparse-union",
-        typeIds: unionType.typeIds,
-        children: unionType.children.map((arrowField) => serializeArrowField(arrowField)),
-        typeIdToChildIndex: { ...unionType.typeIdToChildIndex }
-      };
-    case arrow.Dictionary:
-      const dictionaryType = arrowType;
-      return {
-        type: "dictionary",
-        id: dictionaryType.id,
-        indices: serializeArrowDictionaryKeyType(dictionaryType.indices),
-        dictionary: serializeArrowType(dictionaryType.dictionary),
-        isOrdered: dictionaryType.isOrdered
-      };
-    default:
-      throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);
-  }
-}
-function getOptionalArrowConstructor(typeName) {
-  return arrow[typeName];
-}
-function isArrowViewType(arrowType, viewTypeName) {
-  const constructor = getOptionalArrowConstructor(viewTypeName);
-  if (constructor && arrowType instanceof constructor) {
-    return true;
-  }
-  const guards = arrow.DataType;
-  const guard = viewTypeName === "BinaryView" ? guards.isBinaryView : guards.isUtf8View;
-  return Boolean(guard == null ? void 0 : guard(arrowType));
-}
-function isOptionalArrowType(arrowType, typeName) {
-  const constructor = getOptionalArrowConstructor(typeName);
-  return Boolean(constructor && arrowType instanceof constructor);
-}
-function serializeArrowDictionaryKeyType(arrowType) {
-  if (arrowType instanceof arrow.Int) {
-    const prefix = arrowType.isSigned ? "int" : "uint";
-    const keyType = `${prefix}${arrowType.bitWidth}`;
-    if (isSchemaDictionaryKeyType(keyType)) {
-      return keyType;
-    }
-  }
-  switch (arrowType.constructor) {
-    case arrow.Int8:
-      return "int8";
-    case arrow.Int16:
-      return "int16";
-    case arrow.Int32:
-      return "int32";
-    case arrow.Uint8:
-      return "uint8";
-    case arrow.Uint16:
-      return "uint16";
-    case arrow.Uint32:
-      return "uint32";
-    default:
-      throw new Error(`arrow dictionary index type not supported: ${arrowType.constructor.name}`);
-  }
-}
-function isSchemaDictionaryKeyType(keyType) {
-  return ["int8", "int16", "int32", "uint8", "uint16", "uint32"].includes(keyType);
-}
-var arrow;
-var init_convert_arrow_schema = __esm({
-  "../core/src/schema-utils/lib/schema/convert-arrow-schema.ts"() {
-    "use strict";
-    arrow = __toESM(require("apache-arrow"), 1);
-  }
-});
-
-// ../core/src/schema-utils/index.ts
-var init_schema_utils = __esm({
-  "../core/src/schema-utils/index.ts"() {
-    "use strict";
-    init_convert_arrow_schema();
-  }
-});
-
 // src/lib/build-graph-tables.ts
 function buildGraphTables(nodes, edges, shape, declarations) {
   if (shape === "plain-graph-data") {
     return { shape, nodes: Array.from(nodes), edges: Array.from(edges) };
   }
-  if (shape !== "arrow-table" && shape !== "object-row-table") {
+  if (shape !== "arrow" && shape !== "object-row-table") {
     throw new Error(`Unsupported graph shape: ${shape}`);
   }
   const nodeTable = buildGraphTable(nodes, false, shape, declarations == null ? void 0 : declarations.nodes);
@@ -375,8 +98,7 @@ function buildGraphTable(records, isEdge, shape, declarations) {
       type
     );
   }
-  const data = new import_apache_arrow.Table(vectors);
-  return { shape, schema: convertArrowToSchema(data.schema), data };
+  return new import_apache_arrow.Table(vectors);
 }
 function inferAttributeType(values, declarations) {
   const names = new Set(declarations == null ? void 0 : declarations.keys());
@@ -471,7 +193,6 @@ var init_build_graph_tables = __esm({
   "src/lib/build-graph-tables.ts"() {
     "use strict";
     import_apache_arrow = require("apache-arrow");
-    init_schema_utils();
   }
 });
 
@@ -1196,15 +917,15 @@ var init_dot_loader = __esm({
       ...DOTLoader,
       parse: async (data, options) => {
         var _a;
-        return parseDOT(new TextDecoder().decode(data), ((_a = options == null ? void 0 : options.dot) == null ? void 0 : _a.shape) ?? "arrow-table");
+        return parseDOT(new TextDecoder().decode(data), ((_a = options == null ? void 0 : options.dot) == null ? void 0 : _a.shape) ?? "arrow");
       },
       parseSync: (data, options) => {
         var _a;
-        return parseDOT(new TextDecoder().decode(data), ((_a = options == null ? void 0 : options.dot) == null ? void 0 : _a.shape) ?? "arrow-table");
+        return parseDOT(new TextDecoder().decode(data), ((_a = options == null ? void 0 : options.dot) == null ? void 0 : _a.shape) ?? "arrow");
       },
       parseTextSync: (data, options) => {
         var _a;
-        return parseDOT(data, ((_a = options == null ? void 0 : options.dot) == null ? void 0 : _a.shape) ?? "arrow-table");
+        return parseDOT(data, ((_a = options == null ? void 0 : options.dot) == null ? void 0 : _a.shape) ?? "arrow");
       }
     };
   }
@@ -1218,7 +939,7 @@ __export(dot_loader_exports2, {
 module.exports = __toCommonJS(dot_loader_exports2);
 
 // dist/dot-loader-types.js
-var VERSION2 = true ? "5.0.0-beta.1" : "latest";
+var VERSION2 = true ? "5.0.0-beta.10" : "latest";
 async function preload2() {
   const { DOTLoaderWithParser: DOTLoaderWithParser3 } = await Promise.resolve().then(() => (init_dot_loader(), dot_loader_exports));
   return DOTLoaderWithParser3;
@@ -1232,20 +953,20 @@ var DOTLoader2 = {
   mimeTypes: ["text/vnd.graphviz", "text/x-graphviz", "application/vnd.graphviz"],
   text: true,
   worker: false,
+  supportsNativeArrow: true,
   dataType: null,
   batchType: null,
-  options: { dot: { shape: "arrow-table" } },
+  options: { dot: { shape: "arrow" } },
   preload: preload2
 };
 
 // dist/lib/build-graph-tables.js
 var import_apache_arrow2 = require("apache-arrow");
-init_schema_utils();
 function buildGraphTables2(nodes, edges, shape, declarations) {
   if (shape === "plain-graph-data") {
     return { shape, nodes: Array.from(nodes), edges: Array.from(edges) };
   }
-  if (shape !== "arrow-table" && shape !== "object-row-table") {
+  if (shape !== "arrow" && shape !== "object-row-table") {
     throw new Error(`Unsupported graph shape: ${shape}`);
   }
   const nodeTable = buildGraphTable2(nodes, false, shape, declarations == null ? void 0 : declarations.nodes);
@@ -1278,8 +999,7 @@ function buildGraphTable2(records, isEdge, shape, declarations) {
     const type = name === "attributes" ? inferAttributeType2(values, declarations) : name === "directed" ? new import_apache_arrow2.Bool() : new import_apache_arrow2.Utf8();
     vectors[name] = (0, import_apache_arrow2.vectorFromArray)(values.map((value) => normalizeValue2(value, type)), type);
   }
-  const data = new import_apache_arrow2.Table(vectors);
-  return { shape, schema: convertArrowToSchema(data.schema), data };
+  return new import_apache_arrow2.Table(vectors);
 }
 function inferAttributeType2(values, declarations) {
   const names = new Set(declarations == null ? void 0 : declarations.keys());
@@ -2059,15 +1779,15 @@ var DOTLoaderWithParser2 = {
   ...DOTLoader2,
   parse: async (data, options) => {
     var _a;
-    return parseDOT2(new TextDecoder().decode(data), ((_a = options == null ? void 0 : options.dot) == null ? void 0 : _a.shape) ?? "arrow-table");
+    return parseDOT2(new TextDecoder().decode(data), ((_a = options == null ? void 0 : options.dot) == null ? void 0 : _a.shape) ?? "arrow");
   },
   parseSync: (data, options) => {
     var _a;
-    return parseDOT2(new TextDecoder().decode(data), ((_a = options == null ? void 0 : options.dot) == null ? void 0 : _a.shape) ?? "arrow-table");
+    return parseDOT2(new TextDecoder().decode(data), ((_a = options == null ? void 0 : options.dot) == null ? void 0 : _a.shape) ?? "arrow");
   },
   parseTextSync: (data, options) => {
     var _a;
-    return parseDOT2(data, ((_a = options == null ? void 0 : options.dot) == null ? void 0 : _a.shape) ?? "arrow-table");
+    return parseDOT2(data, ((_a = options == null ? void 0 : options.dot) == null ? void 0 : _a.shape) ?? "arrow");
   }
 };
 //# sourceMappingURL=dot-loader.cjs.map