@tangram.gl/tangram-renderer 0.0.0-stage → 0.0.1

package/src/utils/vector.ts

@@ -0,0 +1,197 @@
+// Tangram
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2013-2016 Brett Camper and Mapzen
+// Copyright (c) 2026 vis.gl contributors
+
+/** A numeric vector accepted by Tangram's vector utilities. */
+export type NumericVector = readonly number[];
+
+/** A mutable numeric vector returned or updated by Tangram's vector utilities. */
+export type MutableNumericVector = number[];
+
+function copy(vector: NumericVector): MutableNumericVector {
+  return [...vector];
+}
+
+function negate(vector: NumericVector): MutableNumericVector {
+  return vector.map(component => -component);
+}
+
+function add(left: NumericVector, right: NumericVector): MutableNumericVector {
+  const length = Math.min(left.length, right.length);
+  const result: MutableNumericVector = [];
+  for (let index = 0; index < length; index++) {
+    result[index] = left[index] + right[index];
+  }
+  return result;
+}
+
+function subtract(left: NumericVector, right: NumericVector): MutableNumericVector {
+  const length = Math.min(left.length, right.length);
+  const result: MutableNumericVector = [];
+  for (let index = 0; index < length; index++) {
+    result[index] = left[index] - right[index];
+  }
+  return result;
+}
+
+function signedArea(first: NumericVector, second: NumericVector, third: NumericVector): number {
+  return (
+    (second[0] - first[0]) * (third[1] - first[1]) -
+    (third[0] - first[0]) * (second[1] - first[1])
+  );
+}
+
+function multiply(
+  vector: NumericVector,
+  multiplier: number | NumericVector
+): MutableNumericVector {
+  const length = typeof multiplier === 'number'
+    ? vector.length
+    : Math.min(vector.length, multiplier.length);
+  const result: MutableNumericVector = [];
+  for (let index = 0; index < length; index++) {
+    result[index] = vector[index] * (
+      typeof multiplier === 'number' ? multiplier : multiplier[index]
+    );
+  }
+  return result;
+}
+
+function divide(vector: NumericVector, divisor: number | NumericVector): MutableNumericVector {
+  const length = typeof divisor === 'number'
+    ? vector.length
+    : Math.min(vector.length, divisor.length);
+  const result: MutableNumericVector = [];
+  for (let index = 0; index < length; index++) {
+    result[index] = vector[index] / (typeof divisor === 'number' ? divisor : divisor[index]);
+  }
+  return result;
+}
+
+function perpendicular(first: NumericVector, second: NumericVector): MutableNumericVector {
+  return [second[1] - first[1], first[0] - second[0]];
+}
+
+function rotate(vector: NumericVector, angleRadians: number): MutableNumericVector {
+  const cosine = Math.cos(angleRadians);
+  const sine = Math.sin(angleRadians);
+  return [
+    vector[0] * cosine - vector[1] * sine,
+    vector[0] * sine + vector[1] * cosine
+  ];
+}
+
+function angle([x, y]: NumericVector): number {
+  return Math.atan2(y, x);
+}
+
+function angleBetween(first: NumericVector, second: NumericVector): number {
+  let delta = dot(normalize(copy(first)), normalize(copy(second)));
+  if (delta > 1) {
+    delta = 1;
+  }
+  return Math.acos(delta);
+}
+
+function isEqual(first: NumericVector, second: NumericVector): boolean {
+  for (let index = 0; index < first.length; index++) {
+    if (first[index] !== second[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function lengthSquared(vector: NumericVector): number {
+  if (vector.length === 2) {
+    return vector[0] * vector[0] + vector[1] * vector[1];
+  }
+  if (vector.length >= 3) {
+    return vector[0] * vector[0] + vector[1] * vector[1] + vector[2] * vector[2];
+  }
+  return 0;
+}
+
+function getLength(vector: NumericVector): number {
+  return Math.sqrt(lengthSquared(vector));
+}
+
+function normalize<VectorType extends MutableNumericVector>(vector: VectorType): VectorType {
+  if (vector.length !== 2 && vector.length < 3) {
+    return vector;
+  }
+
+  let magnitudeSquared = vector[0] * vector[0] + vector[1] * vector[1];
+  if (vector.length >= 3) {
+    magnitudeSquared += vector[2] * vector[2];
+  }
+  if (magnitudeSquared === 1) {
+    return vector;
+  }
+
+  const magnitude = Math.sqrt(magnitudeSquared);
+  if (magnitude !== 0) {
+    vector[0] /= magnitude;
+    vector[1] /= magnitude;
+    if (vector.length >= 3) {
+      vector[2] /= magnitude;
+    }
+  } else {
+    vector[0] = 0;
+    vector[1] = 0;
+    if (vector.length >= 3) {
+      vector[2] = 0;
+    }
+  }
+  return vector;
+}
+
+function cross(
+  first: NumericVector,
+  second: NumericVector
+): number | MutableNumericVector | undefined {
+  if (first.length === 2) {
+    return first[0] * second[1] - first[1] * second[0];
+  }
+  if (first.length === 3) {
+    return [
+      first[1] * second[2] - first[2] * second[1],
+      first[2] * second[0] - first[0] * second[2],
+      first[0] * second[1] - first[1] * second[0]
+    ];
+  }
+  return undefined;
+}
+
+function dot(first: NumericVector, second: NumericVector): number {
+  const length = Math.min(first.length, second.length);
+  let result = 0;
+  for (let index = 0; index < length; index++) {
+    result += first[index] * second[index];
+  }
+  return result;
+}
+
+/** Tangram's numeric vector operations. */
+export const Vector = {
+  copy,
+  neg: negate,
+  add,
+  sub: subtract,
+  signed_area: signedArea,
+  mult: multiply,
+  div: divide,
+  perp: perpendicular,
+  rot: rotate,
+  angle,
+  angleBetween,
+  isEqual,
+  lengthSq: lengthSquared,
+  length: getLength,
+  normalize,
+  cross,
+  dot
+};
+
+export default Vector;

package/src/utils/version.ts

@@ -0,0 +1,8 @@
+// Tangram
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2013-2016 Brett Camper and Mapzen
+// Copyright (c) 2026 vis.gl contributors
+
+import {version} from '../../package.json';
+
+export default 'v' + version;

package/src/utils/worker-types.ts

@@ -0,0 +1,79 @@
+// tangram-layers
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/** Worker transport surface; registration still requires a native Worker. */
+export type BrokerWorker = Pick<Worker, 'postMessage' | 'addEventListener'>;
+
+/** Remote method name and optional serialization for non-cloneable log arguments. */
+export type BrokerMethod = string | {method: string; stringify?: boolean};
+
+/** Invocation crossing the main/worker boundary. Arguments are not known to the transport. */
+export interface BrokerInvocation {
+    type: 'main_send' | 'worker_send';
+    message_id: number;
+    method: string;
+    message: unknown[];
+    /** Optional diagnostic target supplied by older callers. */
+    target?: string;
+}
+
+/** Reply crossing the main/worker boundary. Truthy errors reject the pending invocation. */
+export interface BrokerReply {
+    type: 'main_reply' | 'worker_reply';
+    message_id: number;
+    message?: unknown;
+    error?: unknown;
+}
+
+/** Wire packet, decoded once at the transport boundary. */
+export type BrokerPacket = BrokerInvocation | BrokerReply;
+
+/** Promise callbacks retained until a reply arrives. */
+export interface PendingBrokerMessage {
+    method: string;
+    message: unknown[];
+    resolve(value: unknown): void;
+    reject(error: unknown): void;
+}
+
+/** Buffer and its original owner, used for legacy post-transfer cleanup. */
+export interface BrokerTransferable {
+    object: ArrayBuffer;
+    parent: object | null;
+    property: string | number | null;
+}
+
+/** Tuple of remote arguments or the single result wrapped for buffer transfer. */
+export interface TransferEnvelope<Values extends unknown[] = unknown[]> {
+    value: Values;
+    transferables: BrokerTransferable[];
+}
+
+/** The legacy wrapper supports both ordinary calls and construction. */
+export interface TransferEnvelopeFactory {
+    <Values extends unknown[]>(...value: Values): TransferEnvelope<Values>;
+    new <Values extends unknown[]>(...value: Values): TransferEnvelope<Values>;
+}
+
+/** Thread-specific invocation overloads; the caller supplies its remote result contract. */
+export interface BrokerPostMessage {
+    <Result = unknown>(workers: BrokerWorker[], method: BrokerMethod, ...message: unknown[]): Promise<Result[]>;
+    <Result = unknown>(worker: BrokerWorker, method: BrokerMethod, ...message: unknown[]): Promise<Result>;
+    <Result = unknown>(method: BrokerMethod, ...message: unknown[]): Promise<Result>;
+}
+
+/** Staged broker object shared with the logger during circular module initialization. */
+export interface WorkerBrokerApi {
+    targets: Record<string, unknown>;
+    addTarget(name: string, target: unknown): void;
+    removeTarget(name: string): void;
+    postMessage: BrokerPostMessage;
+    /** Installed on the main thread only. */
+    addWorker(worker: Worker): void;
+    /** Main-thread debugging access to pending invocations. */
+    getMessages(): Record<number, PendingBrokerMessage>;
+    /** Main-thread debugging access to the next invocation identifier. */
+    getMessageId(): number;
+    withTransferables: TransferEnvelopeFactory;
+}