@oceanum/layers 0.1.1

package/dist/index.js

@@ -0,0 +1,539 @@
+import { PcolorLayer as q, ParticleLayer as R, PartmeshLayer as A, ContourLayer as B } from "@oceanum/deck-gl-grid";
+import { CompositeLayer as T } from "@deck.gl/core";
+import { Dataset as U } from "@oceanum/datamesh";
+function W(a, e) {
+  const n = { x: a.x, y: a.y };
+  return e.xvector && e.yvector ? (n.u = e.xvector, n.v = e.yvector) : n.c = e.magnitude, n;
+}
+function E(a, e) {
+  const n = { x: a.x, y: a.y };
+  return e.xvector && e.yvector ? (n.u = e.xvector, n.v = e.yvector) : (n.m = e.magnitude, n.d = e.direction), n;
+}
+function O(a) {
+  const e = [];
+  return a.magnitude && e.push(a.magnitude), a.xvector && e.push(a.xvector), a.yvector && e.push(a.yvector), a.direction && e.push(a.direction), e;
+}
+function $(a, e) {
+  if (!a || a.length === 0) return 0;
+  const n = e instanceof Date ? e.getTime() / 1e3 : new Date(e).getTime() / 1e3;
+  let t = 0, l = a.length - 1;
+  for (; t < l; ) {
+    const o = t + l >> 1;
+    a[o] < n ? t = o + 1 : l = o;
+  }
+  return t > 0 && Math.abs(a[t - 1] - n) < Math.abs(a[t] - n) ? t - 1 : t;
+}
+function C(a, e) {
+  return e <= 0 ? 0 : Math.max(0, Math.min(a, e - 1));
+}
+function L(a, e, n) {
+  if (!a || a.length === 0) return [0, 0];
+  const t = a.length < 2 || a[1] >= a[0];
+  let l = 0, o = a.length - 1;
+  if (t) {
+    let r = 0, s = a.length - 1;
+    for (; r < s; ) {
+      const i = r + s >> 1;
+      a[i] < e ? r = i + 1 : s = i;
+    }
+    for (l = Math.max(0, r - 1), r = l, s = a.length - 1; r < s; ) {
+      const i = r + s + 1 >> 1;
+      a[i] > n ? s = i - 1 : r = i;
+    }
+    o = Math.min(a.length - 1, r + 1);
+  } else {
+    let r = 0, s = a.length - 1;
+    for (; r < s; ) {
+      const i = r + s >> 1;
+      a[i] > n ? r = i + 1 : s = i;
+    }
+    for (l = Math.max(0, r - 1), r = l, s = a.length - 1; r < s; ) {
+      const i = r + s + 1 >> 1;
+      a[i] < e ? s = i - 1 : r = i;
+    }
+    o = Math.min(a.length - 1, r + 1);
+  }
+  return [l, o];
+}
+function w(a, e) {
+  return { start: a, stop: e, step: null };
+}
+async function j(a, e, n, t, l, o, r) {
+  const s = {}, i = {}, c = a.variables[e.x], d = a.variables[e.y], [h, m] = await Promise.all([
+    c.get([w(r[0], r[1] + 1)]),
+    d.get([w(o[0], o[1] + 1)])
+  ]);
+  s[e.x] = { data: h }, s[e.y] = { data: m };
+  const v = n.map(async (b) => {
+    const p = a.variables[b];
+    if (!p) return;
+    const x = p.dimensions.map((f) => e.t && f === e.t ? t : e.z && f === e.z ? l : f === e.y ? w(o[0], o[1] + 1) : f === e.x ? w(r[0], r[1] + 1) : null), k = await p.get(x);
+    i[b] = { data: k };
+  });
+  return await Promise.all(v), { coords: s, data_vars: i };
+}
+function M(a, e = 0.1) {
+  const n = a.getBounds(), t = n[0][0], l = n[0][1], o = n[1][0], r = n[1][1], s = o - t, i = r - l, c = s * e, d = i * e;
+  return {
+    west: t - c,
+    south: Math.max(-90, l - d),
+    east: o + c,
+    north: Math.min(90, r + d)
+  };
+}
+function H(a, e) {
+  return e ? a.west >= e.west && a.south >= e.south && a.east <= e.east && a.north <= e.north : !1;
+}
+function V(a, e) {
+  let n = null;
+  const t = ((...l) => {
+    n && clearTimeout(n), n = setTimeout(() => {
+      n = null, a(...l);
+    }, e);
+  });
+  return t.cancel = () => {
+    n && (clearTimeout(n), n = null);
+  }, t;
+}
+const X = {
+  onMetadataError: (a) => console.warn(`[OceanumLayer] ${a.message}`),
+  onChunkError: (a) => console.warn(`[OceanumLayer] ${a.message}`),
+  onVariableError: (a) => console.warn(`[OceanumLayer] ${a.message}`),
+  onValidationError: (a) => console.error(`[OceanumLayer] ${a.message}`)
+}, Y = {
+  serviceUrl: { type: "string", value: "https://layers.app.oceanum.io" },
+  authHeaders: { type: "object", value: {} },
+  layerId: { type: "string", value: null },
+  instance: { type: "string", value: null },
+  time: { type: "string", value: null },
+  level: { type: "number", value: 0 },
+  colormap: { type: "object", value: null },
+  opacity: { type: "number", value: 1 },
+  altitude: { type: "number", value: 0 },
+  globalWrap: { type: "boolean", value: !1 },
+  scale: { type: "number", value: 1 },
+  offset: { type: "number", value: 0 },
+  pickable: { type: "boolean", value: !1 },
+  visible: { type: "boolean", value: !0 },
+  viewportPadding: { type: "number", value: 0.1 },
+  debounceWait: { type: "number", value: 100 },
+  onDataLoad: { type: "function", value: null },
+  errorHandlers: { type: "object", value: null },
+  xvector: { type: "string", value: null },
+  yvector: { type: "string", value: null },
+  magnitude: { type: "string", value: null },
+  direction: { type: "string", value: null },
+  directionConvention: { type: "string", value: "NAUTICAL_FROM" }
+};
+function g(a) {
+  return a.props;
+}
+function _(a) {
+  return a.state;
+}
+function P(a) {
+  return a.context;
+}
+class y extends T {
+  static layerName = "OceanumBaseLayer";
+  static defaultProps = Y;
+  initializeState() {
+    this.setState({
+      dataset: null,
+      loading: !1,
+      slicing: !1,
+      error: null,
+      instance: null,
+      coordNames: null,
+      times: null,
+      nlevels: 0,
+      lats: null,
+      lons: null,
+      timeIndex: 0,
+      levelIndex: 0,
+      latRange: [0, 0],
+      lonRange: [0, 0],
+      fetchedBbox: null,
+      slicedData: null,
+      datakeys: null,
+      debouncedSlice: V(
+        () => this._requestSlice(),
+        g(this).debounceWait
+      )
+    }), this._openDataset();
+  }
+  shouldUpdateState({ changeFlags: e }) {
+    return e.somethingChanged;
+  }
+  updateState({ props: e, oldProps: n, changeFlags: t }) {
+    const l = e, o = n, r = _(this);
+    if (l.debounceWait !== o.debounceWait && (r.debouncedSlice && r.debouncedSlice.cancel(), this.setState({
+      debouncedSlice: V(() => this._requestSlice(), l.debounceWait)
+    })), l.layerId !== o.layerId || l.instance !== o.instance || l.serviceUrl !== o.serviceUrl || this._variablePropsChanged(l, o)) {
+      this._openDataset();
+      return;
+    }
+    if (!r.dataset) return;
+    let s = !1;
+    if (l.time !== o.time && r.times) {
+      const i = l.time ? $(r.times, l.time) : 0;
+      i !== r.timeIndex && (this.setState({ timeIndex: i }), s = !0);
+    }
+    if (l.level !== o.level) {
+      const i = C(l.level || 0, r.nlevels);
+      i !== r.levelIndex && (this.setState({ levelIndex: i }), s = !0);
+    }
+    if (s) {
+      this._requestSlice();
+      return;
+    }
+    if (t.viewportChanged && P(this).viewport) {
+      const i = M(
+        P(this).viewport,
+        l.viewportPadding
+      );
+      if (!H(i, r.fetchedBbox)) {
+        const c = L(r.lons, i.west, i.east), d = L(r.lats, i.south, i.north);
+        this.setState({ latRange: d, lonRange: c, fetchedBbox: i }), r.debouncedSlice && r.debouncedSlice();
+      }
+    }
+  }
+  finalizeState() {
+    const e = _(this);
+    e.debouncedSlice && e.debouncedSlice.cancel();
+  }
+  _variablePropsChanged(e, n) {
+    return e.magnitude !== n.magnitude || e.direction !== n.direction || e.xvector !== n.xvector || e.yvector !== n.yvector || e.directionConvention !== n.directionConvention;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _validateVariableProps(e) {
+    return null;
+  }
+  _buildDatakeys(e) {
+    return { x: e.x, y: e.y };
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _createInnerLayer(e, n) {
+    return null;
+  }
+  _fireError(e, n) {
+    const t = { type: e, ...n };
+    this.setState({ error: t });
+    const l = g(this).errorHandlers || {}, o = `on${e.charAt(0).toUpperCase() + e.slice(1)}Error`, r = l[o] || X[o];
+    r && r(t);
+  }
+  async _openDataset() {
+    const e = g(this), { serviceUrl: n, layerId: t, authHeaders: l } = e;
+    if (!n || !t) return;
+    const o = this._validateVariableProps(e);
+    if (o) {
+      this._fireError("validation", { message: o });
+      return;
+    }
+    this.setState({ loading: !0, error: null });
+    try {
+      let r = `${n}/zarr/${t}`, s = e.instance;
+      if (!s) {
+        const u = await this._discoverInstances(r, l || {});
+        u.length > 0 && (u.sort(), s = u[u.length - 1]);
+      }
+      s && (r = `${r}/${s}`);
+      const i = await U.zarr(r, l || {}), c = i.coordkeys;
+      if (!c || !c.x || !c.y)
+        throw new Error(
+          "Dataset is missing required coordinate mappings (x, y) in _coordinates"
+        );
+      const d = O(e);
+      for (const u of d)
+        if (!i.variables[u]) {
+          const S = Object.keys(i.variables);
+          this._fireError("variable", {
+            layerId: t,
+            variable: u,
+            availableVariables: S,
+            message: `Variable "${u}" not found in dataset. Available: ${S.join(", ")}`
+          }), this.setState({ loading: !1 });
+          return;
+        }
+      const [h, m, v] = await Promise.all([
+        i.variables[c.x]?.get(),
+        i.variables[c.y]?.get(),
+        c.t && i.variables[c.t] ? i.variables[c.t].get() : null
+      ]), b = c.z && i.dimensions[c.z] ? i.dimensions[c.z] : 0, p = e.time && v ? $(v, e.time) : 0, D = C(e.level || 0, b), x = {
+        x: c.x,
+        y: c.y,
+        t: c.t,
+        z: c.z
+      }, k = this._buildDatakeys(x);
+      let f = [
+        0,
+        m ? m.length - 1 : 0
+      ], I = [
+        0,
+        h ? h.length - 1 : 0
+      ], z = null;
+      if (P(this).viewport) {
+        const u = M(
+          P(this).viewport,
+          e.viewportPadding
+        );
+        h && (I = L(h, u.west, u.east)), m && (f = L(m, u.south, u.north)), z = u;
+      }
+      if (this.setState({
+        dataset: i,
+        loading: !1,
+        instance: s,
+        coordNames: x,
+        times: v,
+        nlevels: b,
+        lats: m,
+        lons: h,
+        timeIndex: p,
+        levelIndex: D,
+        latRange: f,
+        lonRange: I,
+        fetchedBbox: z,
+        datakeys: k
+      }), e.onDataLoad) {
+        const u = v ? Array.from(
+          v,
+          (S) => new Date(S * 1e3)
+        ) : [];
+        e.onDataLoad({
+          dataset: i,
+          times: u,
+          nlevels: b,
+          instance: s
+        });
+      }
+      this._requestSlice();
+    } catch (r) {
+      this._fireError("metadata", {
+        layerId: t,
+        message: `Failed to open dataset: ${r.message}`,
+        cause: r
+      }), this.setState({ loading: !1 });
+    }
+  }
+  async _discoverInstances(e, n) {
+    try {
+      const t = await fetch(`${e}/.zmetadata`, {
+        headers: n
+      });
+      if (!t.ok) return [];
+      const l = await t.json();
+      if (!l.metadata) return [];
+      const o = /* @__PURE__ */ new Set();
+      for (const r of Object.keys(l.metadata)) {
+        const s = r.split("/");
+        s.length === 2 && s[1] === ".zgroup" && o.add(s[0]);
+      }
+      return Array.from(o);
+    } catch {
+      return [];
+    }
+  }
+  async _requestSlice() {
+    const e = _(this), { dataset: n, coordNames: t, timeIndex: l, levelIndex: o, latRange: r, lonRange: s } = e;
+    if (!n || !t) return;
+    const i = O(g(this));
+    if (i.length !== 0) {
+      this.setState({ slicing: !0 });
+      try {
+        const c = await j(
+          n,
+          t,
+          i,
+          l,
+          o,
+          r,
+          s
+        );
+        this.setState({ slicedData: c, slicing: !1, error: null });
+      } catch (c) {
+        this._fireError("chunk", {
+          layerId: g(this).layerId,
+          time: e.times ? new Date(e.times[l] * 1e3) : null,
+          level: o,
+          message: `Chunk fetch failed: ${c.message}`,
+          cause: c
+        }), this.setState({ slicing: !1 });
+      }
+    }
+  }
+  renderLayers() {
+    const e = _(this);
+    return !e.slicedData || !e.datakeys ? [] : this._createInnerLayer(e.slicedData, e.datakeys);
+  }
+}
+const F = {
+  ...y.defaultProps,
+  color: { type: "array", value: [200, 200, 200] },
+  material: !1
+};
+class ee extends y {
+  static layerName = "OceanumPcolorLayer";
+  static defaultProps = F;
+  _validateVariableProps(e) {
+    const n = !!e.magnitude, t = e.xvector && e.yvector;
+    return !n && !t ? 'OceanumPcolorLayer requires "magnitude" or "xvector" + "yvector"' : null;
+  }
+  _buildDatakeys(e) {
+    return W(e, this.props);
+  }
+  _createInnerLayer(e, n) {
+    const t = this.props;
+    return new q({
+      id: `${t.id}-inner`,
+      data: e,
+      datakeys: n,
+      opacity: t.opacity,
+      altitude: t.altitude,
+      globalWrap: t.globalWrap,
+      colormap: t.colormap,
+      scale: t.scale,
+      offset: t.offset,
+      color: t.color,
+      material: t.material,
+      pickable: t.pickable,
+      visible: t.visible
+    });
+  }
+}
+const N = {
+  ...y.defaultProps,
+  speed: { type: "number", value: 1 },
+  npart: { type: "number", value: 1e3 },
+  size: { type: "number", value: 3 },
+  length: { type: "number", value: 12 },
+  color: { type: "array", value: [200, 200, 200] }
+};
+class te extends y {
+  static layerName = "OceanumParticleLayer";
+  static defaultProps = N;
+  _validateVariableProps(e) {
+    const n = e.xvector && e.yvector, t = e.magnitude && e.direction;
+    return !n && !t ? 'OceanumParticleLayer requires "xvector" + "yvector" or "magnitude" + "direction"' : n && t ? 'OceanumParticleLayer: provide "xvector" + "yvector" or "magnitude" + "direction", not both' : null;
+  }
+  _buildDatakeys(e) {
+    return E(e, this.props);
+  }
+  _createInnerLayer(e, n) {
+    const t = this.props;
+    return new R({
+      id: `${t.id}-inner`,
+      data: e,
+      datakeys: n,
+      opacity: t.opacity,
+      altitude: t.altitude,
+      globalWrap: t.globalWrap,
+      colormap: t.colormap,
+      scale: t.scale,
+      offset: t.offset,
+      color: t.color,
+      direction: t.directionConvention,
+      speed: t.speed,
+      npart: t.npart,
+      size: t.size,
+      length: t.length,
+      pickable: t.pickable,
+      visible: t.visible
+    });
+  }
+}
+const G = {
+  ...y.defaultProps,
+  speed: { type: "number", value: 1 },
+  size: { type: "number", value: 3 },
+  color: { type: "array", value: [200, 200, 200] },
+  meshShape: { type: "string", value: "cone" },
+  meshLength: { type: "number", value: 4 },
+  meshWidth: { type: "number", value: 1 },
+  meshSize: { type: "number", value: 1 }
+};
+class ae extends y {
+  static layerName = "OceanumPartmeshLayer";
+  static defaultProps = G;
+  _validateVariableProps(e) {
+    const n = e.xvector && e.yvector, t = e.magnitude && e.direction;
+    return !n && !t ? 'OceanumPartmeshLayer requires "xvector" + "yvector" or "magnitude" + "direction"' : n && t ? 'OceanumPartmeshLayer: provide "xvector" + "yvector" or "magnitude" + "direction", not both' : null;
+  }
+  _buildDatakeys(e) {
+    return E(e, this.props);
+  }
+  _createInnerLayer(e, n) {
+    const t = this.props;
+    return new A({
+      id: `${t.id}-inner`,
+      data: e,
+      datakeys: n,
+      opacity: t.opacity,
+      altitude: t.altitude,
+      globalWrap: t.globalWrap,
+      colormap: t.colormap,
+      scale: t.scale,
+      offset: t.offset,
+      color: t.color,
+      direction: t.directionConvention,
+      speed: t.speed,
+      size: t.size,
+      mesh: {
+        shape: t.meshShape,
+        length: t.meshLength,
+        width: t.meshWidth,
+        size: t.meshSize
+      },
+      pickable: t.pickable,
+      visible: t.visible
+    });
+  }
+}
+const J = {
+  ...y.defaultProps,
+  levels: { type: "array", value: [] },
+  labelSize: { type: "number", value: 12 },
+  labelColor: { type: "array", value: [255, 255, 255, 255] },
+  smoothing: { type: "boolean", value: !1 },
+  numLabels: { type: "number", value: 1 },
+  color: { type: "array", value: [200, 200, 200] }
+};
+class ne extends y {
+  static layerName = "OceanumContourLayer";
+  static defaultProps = J;
+  _validateVariableProps(e) {
+    const n = !!e.magnitude, t = e.xvector && e.yvector;
+    return !n && !t ? 'OceanumContourLayer requires "magnitude" or "xvector" + "yvector"' : null;
+  }
+  _buildDatakeys(e) {
+    return W(e, this.props);
+  }
+  _createInnerLayer(e, n) {
+    const t = this.props;
+    return new B({
+      id: `${t.id}-inner`,
+      data: e,
+      datakeys: n,
+      opacity: t.opacity,
+      altitude: t.altitude,
+      globalWrap: t.globalWrap,
+      colormap: t.colormap,
+      scale: t.scale,
+      offset: t.offset,
+      color: t.color,
+      levels: t.levels,
+      labelSize: t.labelSize,
+      labelColor: t.labelColor,
+      smoothing: t.smoothing,
+      numLabels: t.numLabels,
+      pickable: t.pickable,
+      visible: t.visible
+    });
+  }
+}
+export {
+  y as OceanumBaseLayer,
+  ne as OceanumContourLayer,
+  te as OceanumParticleLayer,
+  ae as OceanumPartmeshLayer,
+  ee as OceanumPcolorLayer
+};

package/dist/oceanum-base-layer.d.ts

@@ -0,0 +1,72 @@
+import { CompositeLayer } from './test/__mocks__/deck-gl-core.ts';
+import { Dataset, HttpZarr } from './test/__mocks__/oceanum-datamesh.ts';
+import { CoordNames, VariableProps, ScalarDatakeys, VectorDatakeys } from './utils/coordinates';
+import { SlicedData } from './utils/dataset-slice';
+export interface Colormap {
+    scale: string[];
+    domain: number[];
+}
+export interface OnDataLoadInfo {
+    dataset: Dataset<HttpZarr>;
+    times: Date[];
+    nlevels: number;
+    instance: string | null;
+}
+export interface LayerError {
+    type: string;
+    message: string;
+    layerId?: string;
+    cause?: Error;
+    [key: string]: unknown;
+}
+export interface ErrorHandlers {
+    onMetadataError?: (err: LayerError) => void;
+    onChunkError?: (err: LayerError) => void;
+    onVariableError?: (err: LayerError) => void;
+    onValidationError?: (err: LayerError) => void;
+}
+export interface OceanumLayerProps extends VariableProps {
+    serviceUrl: string | null;
+    authHeaders: Record<string, string>;
+    layerId: string | null;
+    instance: string | null;
+    time: string | Date | null;
+    level: number;
+    colormap: Colormap | null;
+    opacity: number;
+    altitude: number;
+    globalWrap: boolean;
+    scale: number;
+    offset: number;
+    pickable: boolean;
+    visible: boolean;
+    viewportPadding: number;
+    debounceWait: number;
+    onDataLoad: ((info: OnDataLoadInfo) => void) | null;
+    errorHandlers: ErrorHandlers | null;
+    directionConvention: string;
+    id: string;
+}
+type DeckDefaultProp = {
+    type: string;
+    value: any;
+} | boolean;
+export default class OceanumBaseLayer extends CompositeLayer {
+    static layerName: string;
+    static defaultProps: Record<string, DeckDefaultProp>;
+    initializeState(): void;
+    shouldUpdateState({ changeFlags }: any): boolean;
+    updateState({ props, oldProps, changeFlags }: any): void;
+    finalizeState(): void;
+    _variablePropsChanged(props: OceanumLayerProps, oldProps: OceanumLayerProps): boolean;
+    _validateVariableProps(_props: OceanumLayerProps): string | null;
+    _buildDatakeys(coordNames: CoordNames): ScalarDatakeys | VectorDatakeys;
+    _createInnerLayer(_slicedData: SlicedData, _datakeys: ScalarDatakeys | VectorDatakeys): any;
+    private _fireError;
+    private _openDataset;
+    private _discoverInstances;
+    private _requestSlice;
+    renderLayers(): any;
+}
+export {};
+//# sourceMappingURL=oceanum-base-layer.d.ts.map

package/dist/oceanum-base-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oceanum-base-layer.d.ts","sourceRoot":"","sources":["../src/oceanum-base-layer.ts"],"names":[],"mappings":"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"}

package/dist/oceanum-contour-layer.d.ts

@@ -0,0 +1,45 @@
+import { ContourLayer } from './test/__mocks__/deck-gl-grid.ts';
+import { default as OceanumBaseLayer, OceanumLayerProps } from './oceanum-base-layer';
+import { CoordNames, ScalarDatakeys } from './utils/coordinates';
+import { SlicedData } from './utils/dataset-slice';
+export interface OceanumContourLayerProps extends OceanumLayerProps {
+    levels: number[];
+    labelSize: number;
+    labelColor: [number, number, number, number];
+    smoothing: boolean;
+    numLabels: number;
+    color: [number, number, number];
+}
+export default class OceanumContourLayer extends OceanumBaseLayer {
+    static layerName: string;
+    static defaultProps: {
+        levels: {
+            type: string;
+            value: never[];
+        };
+        labelSize: {
+            type: string;
+            value: number;
+        };
+        labelColor: {
+            type: string;
+            value: number[];
+        };
+        smoothing: {
+            type: string;
+            value: boolean;
+        };
+        numLabels: {
+            type: string;
+            value: number;
+        };
+        color: {
+            type: string;
+            value: number[];
+        };
+    };
+    _validateVariableProps(props: OceanumLayerProps): string | null;
+    _buildDatakeys(coordNames: CoordNames): ScalarDatakeys;
+    _createInnerLayer(slicedData: SlicedData, datakeys: ScalarDatakeys): ContourLayer;
+}
+//# sourceMappingURL=oceanum-contour-layer.d.ts.map

package/dist/oceanum-contour-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oceanum-contour-layer.d.ts","sourceRoot":"","sources":["../src/oceanum-contour-layer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,gBAAgB,MAAM,sBAAsB,CAAC;AACpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAExD,MAAM,WAAW,wBAAyB,SAAQ,iBAAiB;IACjE,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7C,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAYD,MAAM,CAAC,OAAO,OAAO,mBAAoB,SAAQ,gBAAgB;IAC/D,OAAgB,SAAS,SAAyB;IAClD,OAAgB,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;MAAgB;IAEnC,sBAAsB,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,GAAG,IAAI;IAS/D,cAAc,CAAC,UAAU,EAAE,UAAU,GAAG,cAAc;IAItD,iBAAiB,CAAC,UAAU,EAAE,UAAU,EAAE,QAAQ,EAAE,cAAc;CAsB5E"}

package/dist/oceanum-particle-layer.d.ts

@@ -0,0 +1,40 @@
+import { ParticleLayer } from './test/__mocks__/deck-gl-grid.ts';
+import { default as OceanumBaseLayer, OceanumLayerProps } from './oceanum-base-layer';
+import { CoordNames, VectorDatakeys } from './utils/coordinates';
+import { SlicedData } from './utils/dataset-slice';
+export interface OceanumParticleLayerProps extends OceanumLayerProps {
+    speed: number;
+    npart: number;
+    size: number;
+    length: number;
+    color: [number, number, number];
+}
+export default class OceanumParticleLayer extends OceanumBaseLayer {
+    static layerName: string;
+    static defaultProps: {
+        speed: {
+            type: string;
+            value: number;
+        };
+        npart: {
+            type: string;
+            value: number;
+        };
+        size: {
+            type: string;
+            value: number;
+        };
+        length: {
+            type: string;
+            value: number;
+        };
+        color: {
+            type: string;
+            value: number[];
+        };
+    };
+    _validateVariableProps(props: OceanumLayerProps): string | null;
+    _buildDatakeys(coordNames: CoordNames): VectorDatakeys;
+    _createInnerLayer(slicedData: SlicedData, datakeys: VectorDatakeys): ParticleLayer;
+}
+//# sourceMappingURL=oceanum-particle-layer.d.ts.map