@loaders.gl/arrow 4.0.4 → 4.1.0-alpha.1

package/dist/arrow-worker.js

@@ -1879,6 +1879,16 @@
     proto.ArrayType = Int32Array;
     return proto[Symbol.toStringTag] = "Date";
   })(Date_.prototype);
+  var DateDay = class extends Date_ {
+    constructor() {
+      super(DateUnit.DAY);
+    }
+  };
+  var DateMillisecond = class extends Date_ {
+    constructor() {
+      super(DateUnit.MILLISECOND);
+    }
+  };
   var Time_ = class extends DataType {
     constructor(unit, bitWidth) {
       super();
@@ -1907,6 +1917,26 @@
     proto.bitWidth = null;
     return proto[Symbol.toStringTag] = "Time";
   })(Time_.prototype);
+  var TimeSecond = class extends Time_ {
+    constructor() {
+      super(TimeUnit.SECOND, 32);
+    }
+  };
+  var TimeMillisecond = class extends Time_ {
+    constructor() {
+      super(TimeUnit.MILLISECOND, 32);
+    }
+  };
+  var TimeMicrosecond = class extends Time_ {
+    constructor() {
+      super(TimeUnit.MICROSECOND, 64);
+    }
+  };
+  var TimeNanosecond = class extends Time_ {
+    constructor() {
+      super(TimeUnit.NANOSECOND, 64);
+    }
+  };
   var Timestamp_ = class extends DataType {
     constructor(unit, timezone) {
       super();
@@ -1927,6 +1957,26 @@
     proto.ArrayType = Int32Array;
     return proto[Symbol.toStringTag] = "Timestamp";
   })(Timestamp_.prototype);
+  var TimestampSecond = class extends Timestamp_ {
+    constructor(timezone) {
+      super(TimeUnit.SECOND, timezone);
+    }
+  };
+  var TimestampMillisecond = class extends Timestamp_ {
+    constructor(timezone) {
+      super(TimeUnit.MILLISECOND, timezone);
+    }
+  };
+  var TimestampMicrosecond = class extends Timestamp_ {
+    constructor(timezone) {
+      super(TimeUnit.MICROSECOND, timezone);
+    }
+  };
+  var TimestampNanosecond = class extends Timestamp_ {
+    constructor(timezone) {
+      super(TimeUnit.NANOSECOND, timezone);
+    }
+  };
   var Interval_ = class extends DataType {
     constructor(unit) {
       super();
@@ -1945,6 +1995,16 @@
     proto.ArrayType = Int32Array;
     return proto[Symbol.toStringTag] = "Interval";
   })(Interval_.prototype);
+  var IntervalDayTime = class extends Interval_ {
+    constructor() {
+      super(IntervalUnit.DAY_TIME);
+    }
+  };
+  var IntervalYearMonth = class extends Interval_ {
+    constructor() {
+      super(IntervalUnit.YEAR_MONTH);
+    }
+  };
   var List = class extends DataType {
     constructor(child) {
       super();
@@ -11893,14 +11953,189 @@ return true;`);
     }
     return {
       shape: "columnar-table",
+      schema: table.schema,
       data: columnarTable
     };
   }
 
+  // src/schema/convert-arrow-schema.ts
+  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) {
+    switch (arrowType.constructor) {
+      case Null:
+        return "null";
+      case Binary:
+        return "binary";
+      case Bool:
+        return "bool";
+      case Int_:
+        const intType = arrowType;
+        return `${intType.isSigned ? "u" : ""}int${intType.bitWidth}`;
+      case Int8:
+        return "int8";
+      case Int16:
+        return "int16";
+      case Int32:
+        return "int32";
+      case Int64:
+        return "int64";
+      case Uint8:
+        return "uint8";
+      case Uint16:
+        return "uint16";
+      case Uint32:
+        return "uint32";
+      case Uint64:
+        return "uint64";
+      case Float:
+        const precision = arrowType.precision;
+        switch (precision) {
+          case Precision.HALF:
+            return "float16";
+          case Precision.SINGLE:
+            return "float32";
+          case Precision.DOUBLE:
+            return "float64";
+          default:
+            return "float16";
+        }
+      case Float16:
+        return "float16";
+      case Float32:
+        return "float32";
+      case Float64:
+        return "float64";
+      case Utf8:
+        return "utf8";
+      case Decimal:
+        const decimal = arrowType;
+        return {
+          type: "decimal",
+          bitWidth: decimal.bitWidth,
+          precision: decimal.precision,
+          scale: decimal.scale
+        };
+      case Date_:
+        const dateUnit = arrowType.unit;
+        return dateUnit === DateUnit.DAY ? "date-day" : "date-millisecond";
+      case DateDay:
+        return "date-day";
+      case DateMillisecond:
+        return "date-millisecond";
+      case Time_:
+        const timeUnit = arrowType.unit;
+        switch (timeUnit) {
+          case TimeUnit.SECOND:
+            return "time-second";
+          case TimeUnit.MILLISECOND:
+            return "time-millisecond";
+          case TimeUnit.MICROSECOND:
+            return "time-microsecond";
+          case TimeUnit.NANOSECOND:
+            return "time-nanosecond";
+          default:
+            return "time-second";
+        }
+      case TimeMillisecond:
+        return "time-millisecond";
+      case TimeSecond:
+        return "time-second";
+      case TimeMicrosecond:
+        return "time-microsecond";
+      case TimeNanosecond:
+        return "time-nanosecond";
+      case Timestamp_:
+        const timeStampUnit = arrowType.unit;
+        switch (timeStampUnit) {
+          case TimeUnit.SECOND:
+            return "timestamp-second";
+          case TimeUnit.MILLISECOND:
+            return "timestamp-millisecond";
+          case TimeUnit.MICROSECOND:
+            return "timestamp-microsecond";
+          case TimeUnit.NANOSECOND:
+            return "timestamp-nanosecond";
+          default:
+            return "timestamp-second";
+        }
+      case TimestampSecond:
+        return "timestamp-second";
+      case TimestampMillisecond:
+        return "timestamp-millisecond";
+      case TimestampMicrosecond:
+        return "timestamp-microsecond";
+      case TimestampNanosecond:
+        return "timestamp-nanosecond";
+      case Interval_:
+        const intervalUnit = arrowType.unit;
+        switch (intervalUnit) {
+          case IntervalUnit.DAY_TIME:
+            return "interval-daytime";
+          case IntervalUnit.YEAR_MONTH:
+            return "interval-yearmonth";
+          default:
+            return "interval-daytime";
+        }
+      case IntervalDayTime:
+        return "interval-daytime";
+      case IntervalYearMonth:
+        return "interval-yearmonth";
+      case Map_:
+        const mapType = arrowType;
+        return {
+          type: "map",
+          keysSorted: mapType.keysSorted,
+          children: mapType.children.map((arrowField) => serializeArrowField(arrowField))
+        };
+      case List:
+        const listType = arrowType;
+        const listField = listType.valueField;
+        return {
+          type: "list",
+          children: [serializeArrowField(listField)]
+        };
+      case FixedSizeList:
+        const fixedSizeList = arrowType;
+        return {
+          type: "fixed-size-list",
+          listSize: fixedSizeList.listSize,
+          children: [serializeArrowField(fixedSizeList.children[0])]
+        };
+      case Struct:
+        const structType = arrowType;
+        return {
+          type: "struct",
+          children: structType.children.map((arrowField) => serializeArrowField(arrowField))
+        };
+      default:
+        throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);
+    }
+  }
+
   // src/parsers/parse-arrow-sync.ts
   function parseArrowSync(arrayBuffer, options) {
     const apacheArrowTable = tableFromIPC([new Uint8Array(arrayBuffer)]);
-    const arrowTable = { shape: "arrow-table", data: apacheArrowTable };
+    const arrowTable = {
+      shape: "arrow-table",
+      schema: serializeArrowSchema(apacheArrowTable.schema),
+      data: apacheArrowTable
+    };
     const shape = options?.shape || "arrow-table";
     switch (shape) {
       case "arrow-table":
@@ -11939,7 +12174,7 @@ return true;`);
   }
 
   // src/arrow-loader.ts
-  var VERSION = true ? "4.0.4" : "latest";
+  var VERSION = true ? "4.1.0-alpha.1" : "latest";
   var ArrowWorkerLoader = {
     name: "Apache Arrow",
     id: "arrow",