@nika-js/onlymap 0.3.0 → 0.3.2

package/dist/index-idvzm9MK.js

@@ -0,0 +1,594 @@
+import { i as E, j as S, k as R, n as N, o as h, p as w, q as O, s as W, r as x, t as I, v as B, w as _, x as P, y as k, A as $, B as z, E as v, F, H as C, I as U, J as p, K as M } from "./index-DYtODPDb.js";
+import { N as $e, R as ze, _ as ve, O as Ce, P as Ue, Q as Me, S as je, T as De, U as Je, X as qe, Y as He, Z as Ve, $ as Ge, a0 as Ke, a1 as Qe, a2 as Xe, a3 as Ye, a4 as Ze, a5 as et, a6 as tt, a7 as nt, a8 as rt, a9 as at, aa as st, ab as ot } from "./index-DYtODPDb.js";
+import { g as j, i as D } from "./table-accessors-CYWTzpQI.js";
+async function J(t, e, n = {}, r = {}) {
+  const a = E(t), s = S.getWorkerFarm(n), { source: o } = n, c = { name: a, source: o };
+  o || (c.url = R(t, n));
+  const i = s.getWorkerPool(c), u = n.jobName || t.name, d = await i.startJob(
+    u,
+    // eslint-disable-next-line
+    q.bind(null, r)
+  ), y = N(n);
+  return d.postMessage("process", { input: e, options: y }), (await d.result).result;
+}
+async function q(t, e, n, r) {
+  switch (n) {
+    case "done":
+      e.done(r);
+      break;
+    case "error":
+      e.error(new Error(r.error));
+      break;
+    case "process":
+      const { id: a, input: s, options: o } = r;
+      try {
+        if (!t.process) {
+          e.postMessage("error", { id: a, error: "Worker not set up to process on main thread" });
+          return;
+        }
+        const c = await t.process(s, o);
+        e.postMessage("done", { id: a, result: c });
+      } catch (c) {
+        const i = c instanceof Error ? c.message : "unknown error";
+        e.postMessage("error", { id: a, error: i });
+      }
+      break;
+    default:
+      console.warn(`process-on-worker: unknown message ${n}`);
+  }
+}
+function H(t, e) {
+  if (!S.isSupported())
+    return !1;
+  const n = e?._nodeWorkers ?? e?.core?._nodeWorkers, r = e?.worker ?? e?.core?.worker;
+  return !h && !n ? !1 : !!(t.worker && r);
+}
+async function* me(t, e = {}) {
+  const n = new TextDecoder(void 0, e);
+  for await (const r of t)
+    yield typeof r == "string" ? r : n.decode(r, { stream: !0 });
+}
+async function* we(t) {
+  const e = new TextEncoder();
+  for await (const n of t)
+    yield typeof n == "string" ? e.encode(n).buffer : n;
+}
+async function* pe(t) {
+  let e = "";
+  for await (const n of t) {
+    e += n;
+    let r;
+    for (; (r = e.indexOf(`
+`)) >= 0; ) {
+      const a = e.slice(0, r + 1);
+      e = e.slice(r + 1), yield a;
+    }
+  }
+  e.length > 0 && (yield e);
+}
+async function* ge(t) {
+  let e = 1;
+  for await (const n of t)
+    yield { counter: e, line: n }, e++;
+}
+const V = "4.4.3", Te = {
+  dataType: null,
+  batchType: null,
+  name: "JSON",
+  id: "json",
+  module: "json",
+  version: V,
+  extensions: ["json", "geojson"],
+  mimeTypes: ["application/json"],
+  category: "json",
+  text: !0,
+  parseTextSync: g,
+  parse: async (t) => g(new TextDecoder().decode(t)),
+  options: {}
+};
+function g(t) {
+  return JSON.parse(t);
+}
+class G {
+  handle;
+  size;
+  bigsize;
+  url;
+  constructor(e) {
+    this.handle = e instanceof ArrayBuffer ? new Blob([e]) : e, this.size = e instanceof ArrayBuffer ? e.byteLength : e.size, this.bigsize = BigInt(this.size), this.url = e instanceof File ? e.name : "";
+  }
+  async close() {
+  }
+  async stat() {
+    return {
+      size: this.handle.size,
+      bigsize: BigInt(this.handle.size),
+      isDirectory: !1
+    };
+  }
+  async read(e, n) {
+    return await this.handle.slice(Number(e), Number(e) + Number(n)).arrayBuffer();
+  }
+}
+const f = new Error("Not implemented");
+class K {
+  handle;
+  size = 0;
+  bigsize = 0n;
+  url = "";
+  constructor(e, n, r) {
+    if (globalThis.loaders?.NodeFile)
+      return new globalThis.loaders.NodeFile(e, n, r);
+    throw h ? new Error("Can't instantiate NodeFile in browser.") : new Error("Can't instantiate NodeFile. Make sure to import @loaders.gl/polyfills first.");
+  }
+  /** Read data */
+  async read(e, n) {
+    throw f;
+  }
+  /** Write to file. The number of bytes written will be returned */
+  async write(e, n, r) {
+    throw f;
+  }
+  /** Get information about file */
+  async stat() {
+    throw f;
+  }
+  /** Truncates the file descriptor. Only available on NodeFile. */
+  async truncate(e) {
+    throw f;
+  }
+  /** Append data to a file. Only available on NodeFile. */
+  async append(e) {
+    throw f;
+  }
+  /** Close the file */
+  async close() {
+  }
+}
+async function be(t, e, n) {
+  t instanceof Blob || (t = new Blob([t]));
+  const r = t.slice(e, e + n);
+  return await Q(r);
+}
+async function Q(t) {
+  return await new Promise((e, n) => {
+    const r = new FileReader();
+    r.onload = (a) => e(a?.target?.result), r.onerror = (a) => n(a), r.readAsArrayBuffer(t);
+  });
+}
+function Se(t, e, n, r) {
+  !Array.isArray(e) && !w(e) && (r = void 0, n = e, e = void 0), n = n || {};
+  const s = O(e, r), o = W(t, s, n);
+  if (!o)
+    return null;
+  const c = x(n, o, s), i = I(t), u = () => {
+    throw new Error("parseSync called parse (which is async");
+  };
+  return r = B({ url: i, _parseSync: u, _parse: u, loaders: e }, c, r || null), X(o, t, c, r);
+}
+function X(t, e, n, r) {
+  if (e = _(e, t), t.parseTextSync && typeof e == "string")
+    return t.parseTextSync(e, n);
+  if (t.parseSync && e instanceof ArrayBuffer)
+    return t.parseSync(e, n, r);
+  throw new Error(`${t.name} loader: 'parseSync' not supported by this loader, use 'parse' instead. ${r.url || ""}`);
+}
+function Y(t) {
+  return { ...t, length: j(t), batchType: "data" };
+}
+async function l(t, e, n, r) {
+  const a = Array.isArray(e) ? e : void 0;
+  !Array.isArray(e) && !w(e) && (r = void 0, n = e, e = void 0), t = await t, n = n || {};
+  const s = I(t), o = await P(t, e, n);
+  if (!o)
+    return [];
+  const c = x(n, o, a, s);
+  return r = B({ url: s, _parseInBatches: l, _parse: k, loaders: a }, c, r || null), await Z(o, t, c, r);
+}
+async function Z(t, e, n, r) {
+  const a = await ee(t, e, n, r);
+  if (!n?.core?.metadata)
+    return a;
+  const s = {
+    shape: "metadata",
+    batchType: "metadata",
+    metadata: {
+      _loader: t,
+      _context: r
+    },
+    // Populate with some default fields to avoid crashing
+    data: [],
+    bytesUsed: 0
+  };
+  async function* o(c) {
+    yield s, yield* c;
+  }
+  return o(a);
+}
+async function ee(t, e, n, r) {
+  const a = await $(e, n), s = await re(a, n?.core?.transforms || []);
+  return t.parseInBatches ? t.parseInBatches(s, n, r) : te(s, t, n, r);
+}
+async function* te(t, e, n, r) {
+  const a = await z(t), s = await k(
+    a,
+    e,
+    // TODO - Hack: supply loaders MIME type to ensure we match it
+    { ...n, core: { ...n?.core, mimeType: e.mimeTypes[0] } },
+    r
+  );
+  yield ne(s, e);
+}
+function ne(t, e) {
+  const n = D(t) ? Y(t) : {
+    shape: "unknown",
+    batchType: "data",
+    data: t,
+    length: Array.isArray(t) ? t.length : 1
+  };
+  return n.mimeType = e.mimeTypes[0], n;
+}
+async function re(t, e = []) {
+  let n = t;
+  for await (const r of e)
+    n = r(n);
+  return n;
+}
+function xe(t, e, n, r) {
+  let a;
+  !Array.isArray(e) && !w(e) ? (n = e, a = void 0) : a = e;
+  const s = v(n || {});
+  return Array.isArray(t) ? t.map((c) => T(c, a, n || {}, s)) : T(t, a, n || {}, s);
+}
+async function T(t, e, n, r) {
+  if (typeof t == "string") {
+    const s = await r(t);
+    return Array.isArray(e) ? await l(s, e, n) : await l(s, e, n);
+  }
+  return Array.isArray(e) ? await l(t, e, n) : await l(t, e, n);
+}
+async function ae(t, e, n) {
+  if (e.encode)
+    return await e.encode(t, n);
+  if (e.encodeText) {
+    const r = await e.encodeText(t, n);
+    return F(new TextEncoder().encode(r));
+  }
+  if (e.encodeInBatches) {
+    const r = se(t, e, n), a = [];
+    for await (const s of r)
+      a.push(s);
+    return C(...a);
+  }
+  throw new Error("Writer could not encode data");
+}
+async function Ie(t, e, n) {
+  if (e.text && e.encodeText)
+    return await e.encodeText(t, n);
+  if (e.text) {
+    const r = await ae(t, e, n);
+    return new TextDecoder().decode(r);
+  }
+  throw new Error(`Writer ${e.name} could not encode data as text`);
+}
+function se(t, e, n) {
+  if (e.encodeInBatches) {
+    const r = oe(t);
+    return e.encodeInBatches(r, n);
+  }
+  throw new Error("Writer could not encode data in batches");
+}
+function oe(t) {
+  return [{ ...t, start: 0, end: t.length }];
+}
+async function Be(t, e, n) {
+  const a = { ...U(), ...n };
+  return e.encodeURLtoURL ? ue(e, t, a) : H(e, a) ? await J(e, t, a) : await e.encode(t, a);
+}
+function ce(t, e, n) {
+  if (e.encodeSync)
+    return e.encodeSync(t, n);
+  if (e.encodeTextSync)
+    return F(new TextEncoder().encode(e.encodeTextSync(t, n)));
+  throw new Error(`Writer ${e.name} could not synchronously encode data`);
+}
+async function ke(t, e, n) {
+  if (e.encodeText)
+    return await e.encodeText(t, n);
+  if (e.encodeTextSync)
+    return e.encodeTextSync(t, n);
+  if (e.text) {
+    const r = await e.encode(t, n);
+    return new TextDecoder().decode(r);
+  }
+  throw new Error(`Writer ${e.name} could not encode data as text`);
+}
+function Fe(t, e, n) {
+  if (e.encodeTextSync)
+    return e.encodeTextSync(t, n);
+  if (e.text && e.encodeSync) {
+    const r = ce(t, e, n);
+    return new TextDecoder().decode(r);
+  }
+  throw new Error(`Writer ${e.name} could not encode data as text`);
+}
+function Le(t, e, n) {
+  if (e.encodeInBatches) {
+    const r = fe(t);
+    return e.encodeInBatches(r, n);
+  }
+  throw new Error(`Writer ${e.name} could not encode in batches`);
+}
+async function ie(t, e, n, r) {
+  if (t = p(t), e = p(e), h || !n.encodeURLtoURL)
+    throw new Error();
+  return await n.encodeURLtoURL(t, e, r);
+}
+async function ue(t, e, n) {
+  if (h)
+    throw new Error(`Writer ${t.name} not supported in browser`);
+  const r = b("input");
+  await new K(r, "w").write(e);
+  const s = b("output"), o = await ie(r, s, t, n);
+  return (await M(o)).arrayBuffer();
+}
+function fe(t) {
+  return [{ ...t, start: 0, end: t.length }];
+}
+function b(t) {
+  return `/tmp/${t}`;
+}
+function Ae(t, e, n) {
+  const r = n?.type || "auto";
+  let a = null;
+  if (r === "auto") {
+    for (const s of e)
+      if (typeof t == "string" && s.testURL && s.testURL(t))
+        return s;
+  } else
+    a = le(r, e);
+  if (!a && !n?.nothrow)
+    throw new Error("Not a valid image source type");
+  return a;
+}
+function le(t, e) {
+  for (const n of e)
+    if (n.type === t)
+      return n;
+  return null;
+}
+function Ee(t, e) {
+  if (globalThis.loaders.makeNodeStream)
+    return globalThis.loaders.makeNodeStream(t, e);
+  const n = t[Symbol.asyncIterator] ? t[Symbol.asyncIterator]() : t[Symbol.iterator]();
+  return new ReadableStream(
+    {
+      // Create a byte stream (enables `Response(stream).arrayBuffer()`)
+      // Only supported on Chrome
+      // See: https://developer.mozilla.org/en-US/docs/Web/API/ReadableByteStreamController
+      // @ts-ignore
+      type: "bytes",
+      async pull(r) {
+        try {
+          const { done: a, value: s } = await n.next();
+          a ? r.close() : r.enqueue(new Uint8Array(s));
+        } catch (a) {
+          r.error(a);
+        }
+      },
+      async cancel() {
+        await n?.return?.();
+      }
+    },
+    // options: QueingStrategy<Uint8Array>
+    {
+      // This is bytes, not chunks
+      highWaterMark: 2 ** 24,
+      ...e
+    }
+  );
+}
+const L = "4.4.3", Re = {
+  dataType: null,
+  batchType: null,
+  name: "Null loader",
+  id: "null",
+  module: "core",
+  version: L,
+  worker: !0,
+  mimeTypes: ["application/x.empty"],
+  extensions: ["null"],
+  tests: [() => !1],
+  options: {
+    null: {}
+  }
+}, Ne = {
+  dataType: null,
+  batchType: null,
+  name: "Null loader",
+  id: "null",
+  module: "core",
+  version: L,
+  mimeTypes: ["application/x.empty"],
+  extensions: ["null"],
+  parse: async (t, e, n) => m(),
+  parseSync: m,
+  parseInBatches: async function* (e, n, r) {
+    for await (const a of e)
+      yield m();
+  },
+  tests: [() => !1],
+  options: {
+    null: {}
+  }
+};
+function m(t, e, n) {
+  return null;
+}
+async function Oe(t, e, n = () => {
+}, r = () => {
+}) {
+  if (t = await t, !t.ok)
+    return t;
+  const a = t.body;
+  if (!a)
+    return t;
+  const s = t.headers.get("content-length") || 0, o = s ? parseInt(s) : 0;
+  if (!(o > 0) || typeof ReadableStream > "u" || !a.getReader)
+    return t;
+  const c = new ReadableStream({
+    async start(i) {
+      const u = a.getReader();
+      await A(i, u, 0, o, e, n, r);
+    }
+  });
+  return new Response(c);
+}
+async function A(t, e, n, r, a, s, o) {
+  try {
+    const { done: c, value: i } = await e.read();
+    if (c) {
+      s(), t.close();
+      return;
+    }
+    n += i.byteLength;
+    const u = Math.round(n / r * 100);
+    a(u, { loadedBytes: n, totalBytes: r }), t.enqueue(i), await A(t, e, n, r, a, s, o);
+  } catch (c) {
+    t.error(c), o(c);
+  }
+}
+class We {
+  _fetch;
+  files = {};
+  lowerCaseFiles = {};
+  usedFiles = {};
+  /**
+   * A FileSystem API wrapper around a list of browser 'File' objects
+   * @param files
+   * @param options
+   */
+  constructor(e, n) {
+    this._fetch = n?.fetch || fetch;
+    for (let r = 0; r < e.length; ++r) {
+      const a = e[r];
+      this.files[a.name] = a, this.lowerCaseFiles[a.name.toLowerCase()] = a, this.usedFiles[a.name] = !1;
+    }
+    this.fetch = this.fetch.bind(this);
+  }
+  // implements IFileSystem
+  /**
+   * Implementation of fetch against this file system
+   * Delegates to global fetch for http{s}:// or data://
+   */
+  async fetch(e, n) {
+    if (e.includes("://"))
+      return this._fetch(e, n);
+    const r = this.files[e];
+    if (!r)
+      return new Response(e, { status: 400, statusText: "NOT FOUND" });
+    const s = new Headers(n?.headers).get("Range"), o = s && /bytes=($1)-($2)/.exec(s);
+    if (o) {
+      const i = parseInt(o[1]), u = parseInt(o[2]), d = await r.slice(i, u).arrayBuffer(), y = new Response(d);
+      return Object.defineProperty(y, "url", { value: e }), y;
+    }
+    const c = new Response(r);
+    return Object.defineProperty(c, "url", { value: e }), c;
+  }
+  /**
+   * List filenames in this filesystem
+   * @param dirname
+   * @returns
+   */
+  async readdir(e) {
+    const n = [];
+    for (const r in this.files)
+      n.push(r);
+    return n;
+  }
+  /**
+   * Return information (size) about files in this file system
+   */
+  async stat(e, n) {
+    const r = this.files[e];
+    if (!r)
+      throw new Error(e);
+    return { size: r.size };
+  }
+  /**
+   * Just removes the file from the list
+   */
+  async unlink(e) {
+    delete this.files[e], delete this.lowerCaseFiles[e], this.usedFiles[e] = !0;
+  }
+  // implements IRandomAccessFileSystem
+  // RANDOM ACCESS
+  async openReadableFile(e, n) {
+    return new G(this.files[e]);
+  }
+  // PRIVATE
+  // Supports case independent paths, and file usage tracking
+  _getFile(e, n) {
+    const r = this.files[e] || this.lowerCaseFiles[e];
+    return r && n && (this.usedFiles[e] = !0), r;
+  }
+}
+export {
+  $e as FetchError,
+  Te as JSONLoader,
+  Ne as NullLoader,
+  Re as NullWorkerLoader,
+  ze as RequestScheduler,
+  We as _BrowserFileSystem,
+  Oe as _fetchProgress,
+  Ae as _selectSource,
+  ve as _unregisterLoaders,
+  Ce as assert,
+  z as concatenateArrayBuffersAsync,
+  Ue as createDataSource,
+  Me as document,
+  Be as encode,
+  Le as encodeInBatches,
+  ce as encodeSync,
+  ae as encodeTable,
+  Ie as encodeTableAsText,
+  se as encodeTableInBatches,
+  ke as encodeText,
+  Fe as encodeTextSync,
+  ie as encodeURLtoURL,
+  M as fetchFile,
+  je as forEach,
+  U as getLoaderOptions,
+  De as getPathPrefix,
+  Je as global,
+  qe as isAsyncIterable,
+  h as isBrowser,
+  He as isIterable,
+  Ve as isIterator,
+  Ge as isPromise,
+  Ke as isPureObject,
+  Qe as isReadableStream,
+  Xe as isResponse,
+  Ye as isWorker,
+  Ze as isWritableStream,
+  et as load,
+  xe as loadInBatches,
+  tt as makeIterator,
+  pe as makeLineIterator,
+  ge as makeNumberedLineIterator,
+  Ee as makeStream,
+  me as makeTextDecoderIterator,
+  we as makeTextEncoderIterator,
+  k as parse,
+  l as parseInBatches,
+  Se as parseSync,
+  be as readArrayBuffer,
+  nt as registerLoaders,
+  p as resolvePath,
+  P as selectLoader,
+  W as selectLoaderSync,
+  rt as self,
+  at as setLoaderOptions,
+  st as setPathPrefix,
+  ot as window
+};

package/dist/index.d.ts

@@ -78,6 +78,7 @@ export { Layer, CompositeLayer, LayerExtension, WebMercatorViewport, COORDINATE_
 export { GeoJsonLayer, ScatterplotLayer, IconLayer, BitmapLayer } from "@deck.gl/layers";
 export { TileLayer, Tile3DLayer } from "@deck.gl/geo-layers";
 export { SimpleMeshLayer, ScenegraphLayer } from "@deck.gl/mesh-layers";
+export declare function loadRasterModule(): Promise<typeof import("./raster")>;
 export { compileExpression, AccessorCache, CompileError } from "./expr";
 export type { Shape, CompileOptions, CompiledExpression } from "./expr";
 export { evaluateInSandbox, compileFullJsAccessorBlockInSandbox, sandboxHtml, destroySandbox } from "./csp-sandbox";
@@ -104,4 +105,5 @@ export declare const OmMap: {
     configureLicense: typeof configureLicense;
     validate: typeof validateManifestString;
     snapshotIR: typeof snapshotIR;
+    loadRasterModule: typeof loadRasterModule;
 };

package/dist/ir.d.ts

@@ -9,9 +9,12 @@
 export interface LayerMeta {
     label?: string;
     color?: string;
+    /** Statically-derived color symbology (spec: "Built-in widgets / legend") — set when get-fill-color is a recognizable scale()/categorical expression. */
+    legend?: LegendSpec;
 }
 export type { Shape } from "./expr";
 import type { Shape } from "./expr";
+import type { LegendSpec } from "./legend-spec";
 /**
  * Columnar (GeoArrow-style) data: one array per field instead of one object
  * per row (spec: "Columnar / GeoArrow Ingestion"). Produced by the Data

package/dist/layer-registry.d.ts

@@ -15,7 +15,16 @@ export interface PropDescriptor {
 }
 export interface LayerSchema {
     type: string;
-    deckClass: new (props: Record<string, unknown>) => Layer;
+    /** Absent only for lazy entries whose chunk hasn't loaded yet (see `loadClass`). */
+    deckClass?: new (props: Record<string, unknown>) => Layer;
+    /**
+     * Lazy-chunk seam (spec: "Raster / GeoTIFF"): a curated entry may ship its
+     * SCHEMA eagerly (attribute resolution and validation need it at parse
+     * time) while the deck class arrives via dynamic import on first use.
+     * `ensureLayerClass` runs the load exactly once; until it settles the
+     * runtime simply skips the layer and re-applies when the class lands.
+     */
+    loadClass?: () => Promise<new (props: Record<string, unknown>) => Layer>;
     props: PropDescriptor[];
     /** Hand-authored (curated, ~15) vs. runtime-derived from defaultProps (HU1 tiering). */
     tier: "curated" | "auto-derived";
@@ -23,5 +32,10 @@ export interface LayerSchema {
 export declare function registerLayer(schema: Omit<LayerSchema, "tier"> & {
     tier?: LayerSchema["tier"];
 }): void;
+/**
+ * Kick (or join) the lazy class load for a schema. Returns null when there
+ * is nothing to load (class already present, or a plain eager entry).
+ */
+export declare function ensureLayerClass(schema: LayerSchema): Promise<void> | null;
 export declare function getLayerSchema(type: string): LayerSchema | undefined;
 export declare function getAllLayerSchemas(): ReadonlyMap<string, LayerSchema>;