@loaders.gl/schema 3.1.0-alpha.2 → 3.1.0-beta.1

package/dist/es5/lib/schema/impl/schema.js

@@ -0,0 +1,103 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _assert = require("../../utils/assert");
+
+class Schema {
+  constructor(fields, metadata) {
+    (0, _defineProperty2.default)(this, "fields", void 0);
+    (0, _defineProperty2.default)(this, "metadata", void 0);
+    (0, _assert.assert)(Array.isArray(fields));
+    checkNames(fields);
+    this.fields = fields;
+    this.metadata = metadata || new Map();
+  }
+
+  compareTo(other) {
+    if (this.metadata !== other.metadata) {
+      return false;
+    }
+
+    if (this.fields.length !== other.fields.length) {
+      return false;
+    }
+
+    for (let i = 0; i < this.fields.length; ++i) {
+      if (!this.fields[i].compareTo(other.fields[i])) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  select(...columnNames) {
+    const nameMap = Object.create(null);
+
+    for (const name of columnNames) {
+      nameMap[name] = true;
+    }
+
+    const selectedFields = this.fields.filter(field => nameMap[field.name]);
+    return new Schema(selectedFields, this.metadata);
+  }
+
+  selectAt(...columnIndices) {
+    const selectedFields = columnIndices.map(index => this.fields[index]).filter(Boolean);
+    return new Schema(selectedFields, this.metadata);
+  }
+
+  assign(schemaOrFields) {
+    let fields;
+    let metadata = this.metadata;
+
+    if (schemaOrFields instanceof Schema) {
+      const otherSchema = schemaOrFields;
+      fields = otherSchema.fields;
+      metadata = mergeMaps(mergeMaps(new Map(), this.metadata), otherSchema.metadata);
+    } else {
+      fields = schemaOrFields;
+    }
+
+    const fieldMap = Object.create(null);
+
+    for (const field of this.fields) {
+      fieldMap[field.name] = field;
+    }
+
+    for (const field of fields) {
+      fieldMap[field.name] = field;
+    }
+
+    const mergedFields = Object.values(fieldMap);
+    return new Schema(mergedFields, metadata);
+  }
+
+}
+
+exports.default = Schema;
+
+function checkNames(fields) {
+  const usedNames = {};
+
+  for (const field of fields) {
+    if (usedNames[field.name]) {
+      console.warn('Schema: duplicated field name', field.name, field);
+    }
+
+    usedNames[field.name] = true;
+  }
+}
+
+function mergeMaps(m1, m2) {
+  return new Map([...(m1 || new Map()), ...(m2 || new Map())]);
+}
+//# sourceMappingURL=schema.js.map

package/dist/es5/lib/schema/impl/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/lib/schema/impl/schema.ts"],"names":["Schema","constructor","fields","metadata","Array","isArray","checkNames","Map","compareTo","other","length","i","select","columnNames","nameMap","Object","create","name","selectedFields","filter","field","selectAt","columnIndices","map","index","Boolean","assign","schemaOrFields","otherSchema","mergeMaps","fieldMap","mergedFields","values","usedNames","console","warn","m1","m2"],"mappings":"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","sourcesContent":["import {assert} from '../../utils/assert';\nimport Field from './field';\n\nexport type SchemaMetadata = Map<string, any>;\n\n/**\n * ArrowJS `Schema` API-compatible class for row-based tables (returned from `DataTable`)\n * https://loaders.gl/arrowjs/docs/api-reference/schema\n */\nexport default class Schema {\n  fields: Field[];\n  // TODO - Arrow just allows Map<string, string>\n  metadata: SchemaMetadata;\n\n  constructor(fields: Field[], metadata?: SchemaMetadata) {\n    assert(Array.isArray(fields));\n    checkNames(fields);\n    // For kepler fields, create arrow compatible `Fields` that have kepler fields as `metadata`\n    this.fields = fields;\n    this.metadata = metadata || new Map();\n  }\n\n  // TODO - arrow only seems to compare fields, not metadata\n  compareTo(other: Schema): boolean {\n    if (this.metadata !== other.metadata) {\n      return false;\n    }\n    if (this.fields.length !== other.fields.length) {\n      return false;\n    }\n    for (let i = 0; i < this.fields.length; ++i) {\n      if (!this.fields[i].compareTo(other.fields[i])) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  select(...columnNames: string[]): Schema {\n    // Ensure column names reference valid fields\n    const nameMap = Object.create(null);\n    for (const name of columnNames) {\n      nameMap[name] = true;\n    }\n    const selectedFields = this.fields.filter((field) => nameMap[field.name]);\n    return new Schema(selectedFields, this.metadata);\n  }\n\n  selectAt(...columnIndices: number[]): Schema {\n    // Ensure column indices reference valid fields\n    const selectedFields = columnIndices.map((index) => this.fields[index]).filter(Boolean);\n    return new Schema(selectedFields, this.metadata);\n  }\n\n  assign(schemaOrFields: Schema | Field[]): Schema {\n    let fields: Field[];\n    let metadata: SchemaMetadata = this.metadata;\n\n    if (schemaOrFields instanceof Schema) {\n      const otherSchema = schemaOrFields;\n      fields = otherSchema.fields;\n      metadata = mergeMaps(mergeMaps(new Map(), this.metadata), otherSchema.metadata);\n    } else {\n      fields = schemaOrFields;\n    }\n\n    // Create a merged list of fields, overwrite fields in place, new fields at end\n    const fieldMap: {[key: string]: Field} = Object.create(null);\n\n    for (const field of this.fields) {\n      fieldMap[field.name] = field;\n    }\n\n    for (const field of fields) {\n      fieldMap[field.name] = field;\n    }\n\n    const mergedFields = Object.values(fieldMap);\n\n    return new Schema(mergedFields, metadata);\n  }\n}\n\n// Warn if any duplicated field names\nfunction checkNames(fields: Field[]): void {\n  const usedNames: Record<string, boolean> = {};\n  for (const field of fields) {\n    if (usedNames[field.name]) {\n      // eslint-disable-next-line\n      console.warn('Schema: duplicated field name', field.name, field);\n    }\n    usedNames[field.name] = true;\n  }\n}\n\nfunction mergeMaps<T>(m1: T, m2: T): T {\n  // @ts-ignore\n  return new Map([...(m1 || new Map()), ...(m2 || new Map())]);\n}\n"],"file":"schema.js"}

package/dist/es5/lib/schema/impl/type.js

@@ -0,0 +1,594 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Type", {
+  enumerable: true,
+  get: function () {
+    return _enum.Type;
+  }
+});
+exports.Struct = exports.FixedSizeList = exports.IntervalYearMonth = exports.IntervalDayTime = exports.Interval = exports.TimestampNanosecond = exports.TimestampMicrosecond = exports.TimestampMillisecond = exports.TimestampSecond = exports.Timestamp = exports.TimeMillisecond = exports.TimeSecond = exports.Time = exports.DateMillisecond = exports.DateDay = exports.Date = exports.Utf8 = exports.Binary = exports.Float64 = exports.Float32 = exports.Float16 = exports.Float = exports.Uint64 = exports.Uint32 = exports.Uint16 = exports.Uint8 = exports.Int64 = exports.Int32 = exports.Int16 = exports.Int8 = exports.Int = exports.Bool = exports.Null = exports.DataType = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _enum = require("./enum");
+
+let _Symbol$toStringTag, _Symbol$toStringTag2, _Symbol$toStringTag3, _Symbol$toStringTag4, _Symbol$toStringTag5, _Symbol$toStringTag6, _Symbol$toStringTag7, _Symbol$toStringTag8;
+
+class DataType {
+  static isNull(x) {
+    return x && x.typeId === _enum.Type.Null;
+  }
+
+  static isInt(x) {
+    return x && x.typeId === _enum.Type.Int;
+  }
+
+  static isFloat(x) {
+    return x && x.typeId === _enum.Type.Float;
+  }
+
+  static isBinary(x) {
+    return x && x.typeId === _enum.Type.Binary;
+  }
+
+  static isUtf8(x) {
+    return x && x.typeId === _enum.Type.Utf8;
+  }
+
+  static isBool(x) {
+    return x && x.typeId === _enum.Type.Bool;
+  }
+
+  static isDecimal(x) {
+    return x && x.typeId === _enum.Type.Decimal;
+  }
+
+  static isDate(x) {
+    return x && x.typeId === _enum.Type.Date;
+  }
+
+  static isTime(x) {
+    return x && x.typeId === _enum.Type.Time;
+  }
+
+  static isTimestamp(x) {
+    return x && x.typeId === _enum.Type.Timestamp;
+  }
+
+  static isInterval(x) {
+    return x && x.typeId === _enum.Type.Interval;
+  }
+
+  static isList(x) {
+    return x && x.typeId === _enum.Type.List;
+  }
+
+  static isStruct(x) {
+    return x && x.typeId === _enum.Type.Struct;
+  }
+
+  static isUnion(x) {
+    return x && x.typeId === _enum.Type.Union;
+  }
+
+  static isFixedSizeBinary(x) {
+    return x && x.typeId === _enum.Type.FixedSizeBinary;
+  }
+
+  static isFixedSizeList(x) {
+    return x && x.typeId === _enum.Type.FixedSizeList;
+  }
+
+  static isMap(x) {
+    return x && x.typeId === _enum.Type.Map;
+  }
+
+  static isDictionary(x) {
+    return x && x.typeId === _enum.Type.Dictionary;
+  }
+
+  get typeId() {
+    return _enum.Type.NONE;
+  }
+
+  compareTo(other) {
+    return this === other;
+  }
+
+}
+
+exports.DataType = DataType;
+
+class Null extends DataType {
+  get typeId() {
+    return _enum.Type.Null;
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'Null';
+  }
+
+  toString() {
+    return 'Null';
+  }
+
+}
+
+exports.Null = Null;
+
+class Bool extends DataType {
+  get typeId() {
+    return _enum.Type.Bool;
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'Bool';
+  }
+
+  toString() {
+    return 'Bool';
+  }
+
+}
+
+exports.Bool = Bool;
+_Symbol$toStringTag = Symbol.toStringTag;
+
+class Int extends DataType {
+  constructor(isSigned, bitWidth) {
+    super();
+    (0, _defineProperty2.default)(this, "isSigned", void 0);
+    (0, _defineProperty2.default)(this, "bitWidth", void 0);
+    this.isSigned = isSigned;
+    this.bitWidth = bitWidth;
+  }
+
+  get typeId() {
+    return _enum.Type.Int;
+  }
+
+  get [_Symbol$toStringTag]() {
+    return 'Int';
+  }
+
+  toString() {
+    return "".concat(this.isSigned ? 'I' : 'Ui', "nt").concat(this.bitWidth);
+  }
+
+}
+
+exports.Int = Int;
+
+class Int8 extends Int {
+  constructor() {
+    super(true, 8);
+  }
+
+}
+
+exports.Int8 = Int8;
+
+class Int16 extends Int {
+  constructor() {
+    super(true, 16);
+  }
+
+}
+
+exports.Int16 = Int16;
+
+class Int32 extends Int {
+  constructor() {
+    super(true, 32);
+  }
+
+}
+
+exports.Int32 = Int32;
+
+class Int64 extends Int {
+  constructor() {
+    super(true, 64);
+  }
+
+}
+
+exports.Int64 = Int64;
+
+class Uint8 extends Int {
+  constructor() {
+    super(false, 8);
+  }
+
+}
+
+exports.Uint8 = Uint8;
+
+class Uint16 extends Int {
+  constructor() {
+    super(false, 16);
+  }
+
+}
+
+exports.Uint16 = Uint16;
+
+class Uint32 extends Int {
+  constructor() {
+    super(false, 32);
+  }
+
+}
+
+exports.Uint32 = Uint32;
+
+class Uint64 extends Int {
+  constructor() {
+    super(false, 64);
+  }
+
+}
+
+exports.Uint64 = Uint64;
+const Precision = {
+  HALF: 16,
+  SINGLE: 32,
+  DOUBLE: 64
+};
+_Symbol$toStringTag2 = Symbol.toStringTag;
+
+class Float extends DataType {
+  constructor(precision) {
+    super();
+    (0, _defineProperty2.default)(this, "precision", void 0);
+    this.precision = precision;
+  }
+
+  get typeId() {
+    return _enum.Type.Float;
+  }
+
+  get [_Symbol$toStringTag2]() {
+    return 'Float';
+  }
+
+  toString() {
+    return "Float".concat(this.precision);
+  }
+
+}
+
+exports.Float = Float;
+
+class Float16 extends Float {
+  constructor() {
+    super(Precision.HALF);
+  }
+
+}
+
+exports.Float16 = Float16;
+
+class Float32 extends Float {
+  constructor() {
+    super(Precision.SINGLE);
+  }
+
+}
+
+exports.Float32 = Float32;
+
+class Float64 extends Float {
+  constructor() {
+    super(Precision.DOUBLE);
+  }
+
+}
+
+exports.Float64 = Float64;
+
+class Binary extends DataType {
+  constructor() {
+    super();
+  }
+
+  get typeId() {
+    return _enum.Type.Binary;
+  }
+
+  toString() {
+    return 'Binary';
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'Binary';
+  }
+
+}
+
+exports.Binary = Binary;
+
+class Utf8 extends DataType {
+  get typeId() {
+    return _enum.Type.Utf8;
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'Utf8';
+  }
+
+  toString() {
+    return 'Utf8';
+  }
+
+}
+
+exports.Utf8 = Utf8;
+const DateUnit = {
+  DAY: 0,
+  MILLISECOND: 1
+};
+_Symbol$toStringTag3 = Symbol.toStringTag;
+
+class Date extends DataType {
+  constructor(unit) {
+    super();
+    (0, _defineProperty2.default)(this, "unit", void 0);
+    this.unit = unit;
+  }
+
+  get typeId() {
+    return _enum.Type.Date;
+  }
+
+  get [_Symbol$toStringTag3]() {
+    return 'Date';
+  }
+
+  toString() {
+    return "Date".concat((this.unit + 1) * 32, "<").concat(DateUnit[this.unit], ">");
+  }
+
+}
+
+exports.Date = Date;
+
+class DateDay extends Date {
+  constructor() {
+    super(DateUnit.DAY);
+  }
+
+}
+
+exports.DateDay = DateDay;
+
+class DateMillisecond extends Date {
+  constructor() {
+    super(DateUnit.MILLISECOND);
+  }
+
+}
+
+exports.DateMillisecond = DateMillisecond;
+const TimeUnit = {
+  SECOND: 1,
+  MILLISECOND: 1e3,
+  MICROSECOND: 1e6,
+  NANOSECOND: 1e9
+};
+_Symbol$toStringTag4 = Symbol.toStringTag;
+
+class Time extends DataType {
+  constructor(unit, bitWidth) {
+    super();
+    (0, _defineProperty2.default)(this, "unit", void 0);
+    (0, _defineProperty2.default)(this, "bitWidth", void 0);
+    this.unit = unit;
+    this.bitWidth = bitWidth;
+  }
+
+  get typeId() {
+    return _enum.Type.Time;
+  }
+
+  toString() {
+    return "Time".concat(this.bitWidth, "<").concat(TimeUnit[this.unit], ">");
+  }
+
+  get [_Symbol$toStringTag4]() {
+    return 'Time';
+  }
+
+}
+
+exports.Time = Time;
+
+class TimeSecond extends Time {
+  constructor() {
+    super(TimeUnit.SECOND, 32);
+  }
+
+}
+
+exports.TimeSecond = TimeSecond;
+
+class TimeMillisecond extends Time {
+  constructor() {
+    super(TimeUnit.MILLISECOND, 32);
+  }
+
+}
+
+exports.TimeMillisecond = TimeMillisecond;
+_Symbol$toStringTag5 = Symbol.toStringTag;
+
+class Timestamp extends DataType {
+  constructor(unit, timezone = null) {
+    super();
+    (0, _defineProperty2.default)(this, "unit", void 0);
+    (0, _defineProperty2.default)(this, "timezone", void 0);
+    this.unit = unit;
+    this.timezone = timezone;
+  }
+
+  get typeId() {
+    return _enum.Type.Timestamp;
+  }
+
+  get [_Symbol$toStringTag5]() {
+    return 'Timestamp';
+  }
+
+  toString() {
+    return "Timestamp<".concat(TimeUnit[this.unit]).concat(this.timezone ? ", ".concat(this.timezone) : '', ">");
+  }
+
+}
+
+exports.Timestamp = Timestamp;
+
+class TimestampSecond extends Timestamp {
+  constructor(timezone = null) {
+    super(TimeUnit.SECOND, timezone);
+  }
+
+}
+
+exports.TimestampSecond = TimestampSecond;
+
+class TimestampMillisecond extends Timestamp {
+  constructor(timezone = null) {
+    super(TimeUnit.MILLISECOND, timezone);
+  }
+
+}
+
+exports.TimestampMillisecond = TimestampMillisecond;
+
+class TimestampMicrosecond extends Timestamp {
+  constructor(timezone = null) {
+    super(TimeUnit.MICROSECOND, timezone);
+  }
+
+}
+
+exports.TimestampMicrosecond = TimestampMicrosecond;
+
+class TimestampNanosecond extends Timestamp {
+  constructor(timezone = null) {
+    super(TimeUnit.NANOSECOND, timezone);
+  }
+
+}
+
+exports.TimestampNanosecond = TimestampNanosecond;
+const IntervalUnit = {
+  DAY_TIME: 0,
+  YEAR_MONTH: 1
+};
+_Symbol$toStringTag6 = Symbol.toStringTag;
+
+class Interval extends DataType {
+  constructor(unit) {
+    super();
+    (0, _defineProperty2.default)(this, "unit", void 0);
+    this.unit = unit;
+  }
+
+  get typeId() {
+    return _enum.Type.Interval;
+  }
+
+  get [_Symbol$toStringTag6]() {
+    return 'Interval';
+  }
+
+  toString() {
+    return "Interval<".concat(IntervalUnit[this.unit], ">");
+  }
+
+}
+
+exports.Interval = Interval;
+
+class IntervalDayTime extends Interval {
+  constructor() {
+    super(IntervalUnit.DAY_TIME);
+  }
+
+}
+
+exports.IntervalDayTime = IntervalDayTime;
+
+class IntervalYearMonth extends Interval {
+  constructor() {
+    super(IntervalUnit.YEAR_MONTH);
+  }
+
+}
+
+exports.IntervalYearMonth = IntervalYearMonth;
+_Symbol$toStringTag7 = Symbol.toStringTag;
+
+class FixedSizeList extends DataType {
+  constructor(listSize, child) {
+    super();
+    (0, _defineProperty2.default)(this, "listSize", void 0);
+    (0, _defineProperty2.default)(this, "children", void 0);
+    this.listSize = listSize;
+    this.children = [child];
+  }
+
+  get typeId() {
+    return _enum.Type.FixedSizeList;
+  }
+
+  get valueType() {
+    return this.children[0].type;
+  }
+
+  get valueField() {
+    return this.children[0];
+  }
+
+  get [_Symbol$toStringTag7]() {
+    return 'FixedSizeList';
+  }
+
+  toString() {
+    return "FixedSizeList[".concat(this.listSize, "]<").concat(this.valueType, ">");
+  }
+
+}
+
+exports.FixedSizeList = FixedSizeList;
+_Symbol$toStringTag8 = Symbol.toStringTag;
+
+class Struct extends DataType {
+  constructor(children) {
+    super();
+    (0, _defineProperty2.default)(this, "children", void 0);
+    this.children = children;
+  }
+
+  get typeId() {
+    return _enum.Type.Struct;
+  }
+
+  toString() {
+    return "Struct<{".concat(this.children.map(f => "".concat(f.name, ":").concat(f.type)).join(', '), "}>");
+  }
+
+  get [_Symbol$toStringTag8]() {
+    return 'Struct';
+  }
+
+}
+
+exports.Struct = Struct;
+//# sourceMappingURL=type.js.map