@kepler.gl/constants 3.3.0-alpha.1 → 3.3.0-alpha.10

package/dist/esm/dataset.js

@@ -0,0 +1,169 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+export var DatasetType = /*#__PURE__*/function (DatasetType) {
+  DatasetType["LOCAL"] = "local";
+  DatasetType["EXTERNALLY_HOSTED"] = "externally-hosted";
+  DatasetType["VECTOR_TILE"] = "vector-tile";
+  DatasetType["RASTER_TILE"] = "raster-tile";
+  DatasetType["WMS_TILE"] = "wms-tile";
+  DatasetType["TILE_3D"] = "tile-3d";
+  DatasetType["BITMAP"] = "bitmap";
+  return DatasetType;
+}({});
+export var REMOTE_FILE_FORMATS = ['auto', 'csv', 'geojson', 'json', 'arrow', 'parquet'];
+export var REMOTE_FILE_MIME_TYPES = {
+  csv: 'text/csv',
+  geojson: 'application/geo+json',
+  json: 'application/json',
+  arrow: 'application/vnd.apache.arrow.file',
+  parquet: 'application/vnd.apache.parquet'
+};
+export var REMOTE_FILE_EXTENSIONS = {
+  csv: 'csv',
+  geojson: 'geojson',
+  json: 'json',
+  arrow: 'arrow',
+  parquet: 'parquet'
+};
+export var MIME_TO_REMOTE_FILE_EXTENSION = {
+  'text/csv': 'csv',
+  'text/tab-separated-values': 'tsv',
+  'application/geo+json': 'geojson',
+  'application/vnd.geo+json': 'geojson',
+  'application/json': 'json',
+  'application/vnd.apache.arrow.file': 'arrow',
+  'application/vnd.apache.arrow.stream': 'arrow',
+  'application/vnd.apache.parquet': 'parquet',
+  'application/x-parquet': 'parquet'
+};
+export var DATASET_REFRESH_INTERVAL_OPTIONS = [{
+  value: 0,
+  labelId: 'datasetTitle.refreshOff'
+}, {
+  value: 10000,
+  labelId: 'datasetTitle.refresh10s'
+}, {
+  value: 15000,
+  labelId: 'datasetTitle.refresh15s'
+}, {
+  value: 60000,
+  labelId: 'datasetTitle.refresh1m'
+}, {
+  value: 300000,
+  labelId: 'datasetTitle.refresh5m'
+}, {
+  value: 900000,
+  labelId: 'datasetTitle.refresh15m'
+}];
+
+/** Select value for a user-entered interval that is not one of the presets. */
+export var DATASET_REFRESH_CUSTOM_VALUE = 'custom';
+/** Default custom poll interval when switching from Off to Custom. */
+export var DATASET_REFRESH_DEFAULT_CUSTOM_MS = 30000;
+export var DATASET_REFRESH_MIN_INTERVAL_MS = 100;
+export function isPresetDatasetRefreshInterval(ms) {
+  return DATASET_REFRESH_INTERVAL_OPTIONS.some(function (option) {
+    return option.value === ms;
+  });
+}
+
+/** Runtime copy of {@link ExternalDatasetMetadata} with `format` renamed to avoid colliding with DATASET_FORMATS. */
+
+export function getDatasetRefreshIntervalMs(metadata) {
+  var value = metadata === null || metadata === void 0 ? void 0 : metadata.refreshIntervalMs;
+  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : 0;
+}
+
+/** Parse a seconds field into ms, or null if the input is not a positive number. */
+export function parseCustomRefreshIntervalMs(secondsText) {
+  var seconds = Number.parseFloat(secondsText);
+  if (!Number.isFinite(seconds) || seconds <= 0) {
+    return null;
+  }
+  return Math.max(DATASET_REFRESH_MIN_INTERVAL_MS, Math.round(seconds * 1000));
+}
+
+/** Display string for the custom seconds input (keeps tenths for sub-second values). */
+export function formatCustomRefreshSeconds(ms) {
+  var seconds = Math.max(DATASET_REFRESH_MIN_INTERVAL_MS, ms) / 1000;
+  if (Number.isInteger(seconds)) {
+    return String(seconds);
+  }
+  return String(Number(seconds.toFixed(3)));
+}
+export function getRemoteSourceFormat(metadata) {
+  var candidate = typeof (metadata === null || metadata === void 0 ? void 0 : metadata.sourceFormat) === 'string' && metadata.sourceFormat || typeof (metadata === null || metadata === void 0 ? void 0 : metadata.format) === 'string' && metadata.format || undefined;
+  if (candidate && candidate !== 'auto' && Object.prototype.hasOwnProperty.call(REMOTE_FILE_EXTENSIONS, candidate)) {
+    return candidate;
+  }
+  return undefined;
+}
+export var RemoteTileFormat = /*#__PURE__*/function (RemoteTileFormat) {
+  RemoteTileFormat["MVT"] = "mvt";
+  RemoteTileFormat["PMTILES"] = "pmtiles";
+  RemoteTileFormat["WMS"] = "wms";
+  return RemoteTileFormat;
+}({});
+export var PMTilesType = /*#__PURE__*/function (PMTilesType) {
+  PMTilesType["RASTER"] = "raster";
+  PMTilesType["MVT"] = "mvt";
+  return PMTilesType;
+}({});
+export var REMOTE_TILE = 'remote';
+
+/**
+ * Raster tileset metadata in STAC Item format. STAC version must be >= 1.0.0,
+ * and the EO and Raster STAC extensions are required. This metadata shape can
+ * be passed to the map to synchronously add a raster tileset.
+ * @see https://github.com/radiantearth/stac-spec/blob/master/item-spec/item-spec.md
+ */
+
+/**
+ * Raster tileset metadata with a remote metadata URL. This metadata can
+ * be passed to the map to asynchronously load a raster tileset.
+ */
+
+export var RasterTileType = /*#__PURE__*/function (RasterTileType) {
+  RasterTileType["STAC"] = "stac";
+  RasterTileType["PMTILES"] = "pmtiles";
+  return RasterTileType;
+}({});
+
+/**
+ * Raster tileset metadata.
+ */
+
+export var TILE3D_PROVIDERS = {
+  google: {
+    name: 'Google 3D Tiles',
+    urlKey: 'google',
+    attribution: {
+      title: 'Built with Google Maps.',
+      url: '',
+      logoUrl: 'https://studio-public-data.foursquare.com/statics/images/google-watermark-white.png',
+      height: 17,
+      bottom: 0
+    }
+  },
+  cesium: {
+    name: 'Cesium ion',
+    urlKey: 'ion.cesium',
+    attribution: {
+      title: 'Cesium.',
+      url: 'https://cesium.com/',
+      height: 19,
+      bottom: 0
+    }
+  },
+  arcgis: {
+    name: 'ArcGIS',
+    urlKey: 'arcgis',
+    attribution: {
+      title: 'Powered by Esri.',
+      url: 'https://arcgis.com/',
+      height: 16
+    }
+  }
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["DatasetType","REMOTE_FILE_FORMATS","REMOTE_FILE_MIME_TYPES","csv","geojson","json","arrow","parquet","REMOTE_FILE_EXTENSIONS","MIME_TO_REMOTE_FILE_EXTENSION","DATASET_REFRESH_INTERVAL_OPTIONS","value","labelId","DATASET_REFRESH_CUSTOM_VALUE","DATASET_REFRESH_DEFAULT_CUSTOM_MS","DATASET_REFRESH_MIN_INTERVAL_MS","isPresetDatasetRefreshInterval","ms","some","option","getDatasetRefreshIntervalMs","metadata","refreshIntervalMs","Number","isFinite","parseCustomRefreshIntervalMs","secondsText","seconds","parseFloat","Math","max","round","formatCustomRefreshSeconds","isInteger","String","toFixed","getRemoteSourceFormat","candidate","sourceFormat","format","undefined","Object","prototype","hasOwnProperty","call","RemoteTileFormat","PMTilesType","REMOTE_TILE","RasterTileType","TILE3D_PROVIDERS","google","name","urlKey","attribution","title","url","logoUrl","height","bottom","cesium","arcgis"],"sources":["../../src/dataset.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nexport enum DatasetType {\n  LOCAL = 'local',\n  EXTERNALLY_HOSTED = 'externally-hosted',\n  VECTOR_TILE = 'vector-tile',\n  RASTER_TILE = 'raster-tile',\n  WMS_TILE = 'wms-tile',\n  TILE_3D = 'tile-3d',\n  BITMAP = 'bitmap'\n}\n\nexport const REMOTE_FILE_FORMATS = ['auto', 'csv', 'geojson', 'json', 'arrow', 'parquet'] as const;\nexport type RemoteFileFormat = (typeof REMOTE_FILE_FORMATS)[number];\n\nexport const REMOTE_FILE_MIME_TYPES: Record<Exclude<RemoteFileFormat, 'auto'>, string> = {\n  csv: 'text/csv',\n  geojson: 'application/geo+json',\n  json: 'application/json',\n  arrow: 'application/vnd.apache.arrow.file',\n  parquet: 'application/vnd.apache.parquet'\n};\n\nexport const REMOTE_FILE_EXTENSIONS: Record<Exclude<RemoteFileFormat, 'auto'>, string> = {\n  csv: 'csv',\n  geojson: 'geojson',\n  json: 'json',\n  arrow: 'arrow',\n  parquet: 'parquet'\n};\n\nexport const MIME_TO_REMOTE_FILE_EXTENSION: Record<string, string> = {\n  'text/csv': 'csv',\n  'text/tab-separated-values': 'tsv',\n  'application/geo+json': 'geojson',\n  'application/vnd.geo+json': 'geojson',\n  'application/json': 'json',\n  'application/vnd.apache.arrow.file': 'arrow',\n  'application/vnd.apache.arrow.stream': 'arrow',\n  'application/vnd.apache.parquet': 'parquet',\n  'application/x-parquet': 'parquet'\n};\n\nexport const DATASET_REFRESH_INTERVAL_OPTIONS: {value: number; labelId: string}[] = [\n  {value: 0, labelId: 'datasetTitle.refreshOff'},\n  {value: 10_000, labelId: 'datasetTitle.refresh10s'},\n  {value: 15_000, labelId: 'datasetTitle.refresh15s'},\n  {value: 60_000, labelId: 'datasetTitle.refresh1m'},\n  {value: 300_000, labelId: 'datasetTitle.refresh5m'},\n  {value: 900_000, labelId: 'datasetTitle.refresh15m'}\n];\n\n/** Select value for a user-entered interval that is not one of the presets. */\nexport const DATASET_REFRESH_CUSTOM_VALUE = 'custom';\n/** Default custom poll interval when switching from Off to Custom. */\nexport const DATASET_REFRESH_DEFAULT_CUSTOM_MS = 30_000;\nexport const DATASET_REFRESH_MIN_INTERVAL_MS = 100;\n\nexport function isPresetDatasetRefreshInterval(ms: number): boolean {\n  return DATASET_REFRESH_INTERVAL_OPTIONS.some(option => option.value === ms);\n}\n\nexport type ExternalDatasetRefreshStatus = 'idle' | 'loading' | 'error';\n\nexport type ExternalDatasetMetadata = {\n  /** Remote URL of the dataset file. */\n  source: string;\n  /** Optional format hint for extensionless URLs (SAS keys, etc). */\n  format?: Exclude<RemoteFileFormat, 'auto'> | string;\n  /** Last known size of the hosted resource, in bytes. */\n  size?: number;\n  /** Poll interval in ms. Omitted or 0 means manual refresh only. */\n  refreshIntervalMs?: number;\n};\n\n/** Runtime copy of {@link ExternalDatasetMetadata} with `format` renamed to avoid colliding with DATASET_FORMATS. */\nexport type ExternalDatasetRuntimeMetadata = {\n  source: string;\n  sourceFormat?: Exclude<RemoteFileFormat, 'auto'> | string;\n  size?: number;\n  refreshIntervalMs?: number;\n  etag?: string;\n  lastModified?: string;\n  lastFetchedAt?: number;\n  refreshStatus?: ExternalDatasetRefreshStatus;\n  refreshError?: string;\n  /** Download progress 0–100 while `refreshStatus` is `loading`. */\n  refreshProgress?: number;\n};\n\nexport function getDatasetRefreshIntervalMs(metadata?: {refreshIntervalMs?: unknown}): number {\n  const value = metadata?.refreshIntervalMs;\n  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : 0;\n}\n\n/** Parse a seconds field into ms, or null if the input is not a positive number. */\nexport function parseCustomRefreshIntervalMs(secondsText: string): number | null {\n  const seconds = Number.parseFloat(secondsText);\n  if (!Number.isFinite(seconds) || seconds <= 0) {\n    return null;\n  }\n  return Math.max(DATASET_REFRESH_MIN_INTERVAL_MS, Math.round(seconds * 1000));\n}\n\n/** Display string for the custom seconds input (keeps tenths for sub-second values). */\nexport function formatCustomRefreshSeconds(ms: number): string {\n  const seconds = Math.max(DATASET_REFRESH_MIN_INTERVAL_MS, ms) / 1000;\n  if (Number.isInteger(seconds)) {\n    return String(seconds);\n  }\n  return String(Number(seconds.toFixed(3)));\n}\n\nexport function getRemoteSourceFormat(metadata?: {\n  sourceFormat?: unknown;\n  format?: unknown;\n}): string | undefined {\n  const candidate =\n    (typeof metadata?.sourceFormat === 'string' && metadata.sourceFormat) ||\n    (typeof metadata?.format === 'string' && metadata.format) ||\n    undefined;\n  if (\n    candidate &&\n    candidate !== 'auto' &&\n    Object.prototype.hasOwnProperty.call(REMOTE_FILE_EXTENSIONS, candidate)\n  ) {\n    return candidate;\n  }\n  return undefined;\n}\n\nexport enum RemoteTileFormat {\n  MVT = 'mvt',\n  PMTILES = 'pmtiles',\n  WMS = 'wms'\n}\n\nexport enum PMTilesType {\n  RASTER = 'raster',\n  MVT = 'mvt'\n}\n\nexport const REMOTE_TILE = 'remote';\n\nexport type VectorTileDatasetMetadata = {\n  type: typeof REMOTE_TILE;\n  remoteTileFormat: RemoteTileFormat;\n  tilesetDataUrl: string;\n  tilesetMetadataUrl?: string;\n};\n\n/**\n * Raster tileset metadata in STAC Item format. STAC version must be >= 1.0.0,\n * and the EO and Raster STAC extensions are required. This metadata shape can\n * be passed to the map to synchronously add a raster tileset.\n * @see https://github.com/radiantearth/stac-spec/blob/master/item-spec/item-spec.md\n */\nexport type RasterTileLocalMetadata = {\n  type: 'Feature';\n\n  /** URL for tileset metadata. */\n  metadataUrl?: string;\n  stac_version: string;\n  stac_extensions: string[];\n  assets: Record<string, any>;\n};\n\n/**\n * Raster tileset metadata with a remote metadata URL. This metadata can\n * be passed to the map to asynchronously load a raster tileset.\n */\nexport type RasterTileRemoteMetadata = {\n  metadataUrl: string;\n};\n\nexport enum RasterTileType {\n  STAC = 'stac',\n  PMTILES = 'pmtiles'\n}\n\nexport type RasterTileMetadataSourceType = {\n  pmtilesType?: PMTilesType;\n};\n\n/**\n * Raster tileset metadata.\n */\nexport type RasterTileDatasetMetadata = (RasterTileLocalMetadata | RasterTileRemoteMetadata) &\n  RasterTileMetadataSourceType;\n\nexport type WMSDatasetMetadata = {\n  type: typeof REMOTE_TILE;\n  remoteTileFormat: RemoteTileFormat.WMS;\n  tilesetDataUrl: string;\n  tilesetMetadataUrl: string;\n  version: string;\n  layers: {name: string; title: string; boundingBox: number[] | null}[];\n  label?: string;\n  attribution?: string;\n};\n\nexport type Tile3DProviderAttribution = {\n  title: string;\n  url: string;\n  logoUrl?: string;\n  height?: number;\n  bottom?: number;\n};\n\nexport type Tile3DProvider = {\n  name: string;\n  urlKey: string;\n  attribution?: Tile3DProviderAttribution;\n};\n\nexport const TILE3D_PROVIDERS: Record<string, Tile3DProvider> = {\n  google: {\n    name: 'Google 3D Tiles',\n    urlKey: 'google',\n    attribution: {\n      title: 'Built with Google Maps.',\n      url: '',\n      logoUrl:\n        'https://studio-public-data.foursquare.com/statics/images/google-watermark-white.png',\n      height: 17,\n      bottom: 0\n    }\n  },\n  cesium: {\n    name: 'Cesium ion',\n    urlKey: 'ion.cesium',\n    attribution: {title: 'Cesium.', url: 'https://cesium.com/', height: 19, bottom: 0}\n  },\n  arcgis: {\n    name: 'ArcGIS',\n    urlKey: 'arcgis',\n    attribution: {title: 'Powered by Esri.', url: 'https://arcgis.com/', height: 16}\n  }\n};\n\nexport type Tile3DDatasetMetadata = {\n  tile3dUrl: string;\n  tile3dAccessToken?: string;\n  tile3dProvider?: string;\n};\n\nexport type BitmapBounds =\n  | [number, number, number, number]\n  | [[number, number], [number, number], [number, number], [number, number]];\n\nexport type BitmapDatasetMetadata = {\n  imageUrl: string;\n  bounds: BitmapBounds;\n  isDataUri?: boolean;\n};\n"],"mappings":"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","ignoreList":[]}