@takram/three-geospatial 0.1.0 → 0.2.0

package/src/TypedArrayLoader.ts

@@ -3,12 +3,7 @@ import { type Class } from 'type-fest'
 
 import { ArrayBufferLoader } from './ArrayBufferLoader'
 import { type TypedArray } from './typedArray'
-import {
-  parseFloat32Array,
-  parseInt16Array,
-  parseUint16Array,
-  type TypedArrayParser
-} from './typedArrayParsers'
+import { type TypedArrayParser } from './typedArrayParsers'
 
 export abstract class TypedArrayLoader<T extends TypedArray> extends Loader<T> {
   abstract parseTypedArray(buffer: ArrayBuffer): T
@@ -56,15 +51,3 @@ export function createTypedArrayLoader<T extends TypedArray>(
 ): TypedArrayLoader<T> {
   return new (createTypedArrayLoaderClass(parser))()
 }
-
-/** @deprecated Use createTypedArrayLoaderClass instead. */
-export const Int16ArrayLoader =
-  /*#__PURE__*/ createTypedArrayLoaderClass(parseInt16Array)
-
-/** @deprecated Use createTypedArrayLoaderClass instead. */
-export const Uint16ArrayLoader =
-  /*#__PURE__*/ createTypedArrayLoaderClass(parseUint16Array)
-
-/** @deprecated Use createTypedArrayLoaderClass instead. */
-export const Float32ArrayLoader =
-  /*#__PURE__*/ createTypedArrayLoaderClass(parseFloat32Array)

package/src/bufferGeometry.ts

@@ -1,10 +1,36 @@
-import { Box3, BufferAttribute, BufferGeometry, Sphere, Vector3 } from 'three'
+import {
+  Box3,
+  BufferAttribute,
+  BufferGeometry,
+  Sphere,
+  Vector3,
+  type TypedArray,
+  type Vector3Like
+} from 'three'
 
-export interface BufferGeometryLike
-  extends Pick<
-    BufferGeometry,
-    'attributes' | 'index' | 'boundingBox' | 'boundingSphere'
-  > {}
+export interface BufferGeometryLike {
+  attributes: Record<
+    string,
+    {
+      array: TypedArray
+      itemSize: number
+      normalized?: boolean
+    }
+  >
+  index?: {
+    array: TypedArray
+    itemSize: number
+    normalized?: boolean
+  } | null
+  boundingBox?: {
+    min: Vector3Like
+    max: Vector3Like
+  } | null
+  boundingSphere?: {
+    center: Vector3Like
+    radius: number
+  } | null
+}
 
 export function toBufferGeometryLike(
   geometry: BufferGeometry

package/src/constants.ts

@@ -2,5 +2,5 @@ export const STBN_TEXTURE_WIDTH = 128
 export const STBN_TEXTURE_HEIGHT = 128
 export const STBN_TEXTURE_DEPTH = 64
 
-export const DEFAULT_STBN_URL =
-  'https://media.githubusercontent.com/media/takram-design-engineering/three-geospatial/9627216cc50057994c98a2118f3c4a23765d43b9/packages/core/assets/stbn.bin'
+const ref = '9627216cc50057994c98a2118f3c4a23765d43b9'
+export const DEFAULT_STBN_URL = `https://media.githubusercontent.com/media/takram-design-engineering/three-geospatial/${ref}/packages/core/assets/stbn.bin`

package/src/r3f/EllipsoidMesh.tsx

@@ -1,7 +1,7 @@
 import {
   extend,
-  type BufferGeometryNode,
-  type MeshProps
+  type ElementProps,
+  type ThreeElement
 } from '@react-three/fiber'
 import { forwardRef, useRef } from 'react'
 import { mergeRefs } from 'react-merge-refs'
@@ -11,14 +11,12 @@ import { EllipsoidGeometry } from '../EllipsoidGeometry'
 
 declare module '@react-three/fiber' {
   interface ThreeElements {
-    ellipsoidGeometry: BufferGeometryNode<
-      EllipsoidGeometry,
-      typeof EllipsoidGeometry
-    >
+    ellipsoidGeometry: ThreeElement<typeof EllipsoidGeometry>
   }
 }
 
-export interface EllipsoidMeshProps extends Omit<MeshProps, 'args'> {
+export interface EllipsoidMeshProps
+  extends Omit<ElementProps<typeof Mesh>, 'args'> {
   args?: ConstructorParameters<typeof EllipsoidGeometry>
 }
 

package/src/r3f/types.ts

@@ -1,63 +1,13 @@
-import {
-  type NodeProps,
-  type Overwrite,
-  type Color as R3FColor,
-  type Vector2 as R3FVector2,
-  type Vector3 as R3FVector3,
-  type Vector4 as R3FVector4
-} from '@react-three/fiber'
-import {
-  type Color as ColorImpl,
-  type Vector2 as Vector2Impl,
-  type Vector3 as Vector3Impl,
-  type Vector4 as Vector4Impl
-} from 'three'
-import { type WritableKeysOf } from 'type-fest'
-
-import { type Callable } from '../types'
-
-// prettier-ignore
-export type ExtendedProps<T> = {
-  [K in keyof T]:
-    Vector2Impl extends T[K] ? R3FVector2 | T[K] :
-    Vector3Impl extends T[K] ? R3FVector3 | T[K] :
-    Vector4Impl extends T[K] ? R3FVector4 | T[K] :
-    ColorImpl extends T[K] ? R3FColor | T[K] :
-    T[K]
-}
-
-// @react-three/fiber's NonFunctionKeys cannot exclude partial functions.
-// This excludes callback properties, which may be undesirable behavior.
-type NonFunctionKeys<T> = keyof {
-  [K in keyof T as Callable extends T[K] ? never : K]: any
+import { type MathType, type MathTypes } from '@react-three/fiber'
+
+export type OverwriteMathProps<T> = {
+  [K in keyof T]: Exclude<T[K], undefined> extends MathTypes
+    ? T[K] extends undefined
+      ? MathType<Exclude<T[K], undefined>> | undefined
+      : MathType<Exclude<T[K], undefined>>
+    : T[K]
 }
 
-// prettier-ignore
-type WritableNonExtendableKeysOf<T> =
-  | WritableKeysOf<T>
-  | keyof {
-      [K in keyof T as
-        Vector2Impl extends T[K] ? K :
-        Vector3Impl extends T[K] ? K :
-        Vector4Impl extends T[K] ? K :
-        ColorImpl extends T[K] ? K :
-        never
-      ]: any
-    }
-
-export type PassThoughInstanceProps<
-  RefType,
-  Args extends readonly any[],
-  Props
-> = Overwrite<
-  ExtendedProps<{
-    [K in NonFunctionKeys<Props> as K extends WritableNonExtendableKeysOf<Props>
-      ? K
-      : never]: Props[K]
-  }>,
-  NodeProps<RefType, Args>
->
-
 export type ExpandNestedProps<T, Prop extends keyof T & string> = {
   [K in keyof NonNullable<T[Prop]> as K extends string
     ? `${Prop}-${K}`

package/src/typedArray.ts

@@ -2,7 +2,6 @@ import {
   Float16Array,
   type Float16ArrayConstructor
 } from '@petamoriken/float16'
-import invariant from 'tiny-invariant'
 
 export type TypedArray =
   | Int8Array
@@ -28,40 +27,6 @@ export type TypedArrayConstructor =
   | Float32ArrayConstructor
   | Float64ArrayConstructor
 
-/** @deprecated */
-export type TypedArrayElementType =
-  | 'int8'
-  | 'uint8'
-  | 'int16'
-  | 'uint16'
-  | 'int32'
-  | 'uint32'
-  | 'float16'
-  | 'float32'
-  | 'float64'
-
-/** @deprecated Use getTypedArrayTextureDataType instead */
-export function getTypedArrayElementType(
-  array: TypedArray
-): TypedArrayElementType {
-  // prettier-ignore
-  const type = (
-    array instanceof Int8Array ? 'int8' :
-    array instanceof Uint8Array ? 'uint8' :
-    array instanceof Uint8ClampedArray ? 'uint8' :
-    array instanceof Int16Array ? 'int16' :
-    array instanceof Uint16Array ? 'uint16' :
-    array instanceof Int32Array ? 'int32' :
-    array instanceof Uint32Array ? 'uint32' :
-    array instanceof Float16Array ? 'float16' :
-    array instanceof Float32Array ? 'float32' :
-    array instanceof Float64Array ? 'float64' :
-    null
-  )
-  invariant(type != null)
-  return type
-}
-
 export function isTypedArray(value: unknown): value is TypedArray {
   return (
     value instanceof Int8Array ||

package/types/ArrayBufferLoader.d.ts

@@ -1,5 +1,4 @@
 import { Loader } from 'three';
-
 export declare class ArrayBufferLoader extends Loader<ArrayBuffer> {
     load(url: string, onLoad: (data: ArrayBuffer) => void, onProgress?: (event: ProgressEvent) => void, onError?: (error: unknown) => void): void;
 }

package/types/DataLoader.d.ts

@@ -1,10 +1,9 @@
-import { Callable } from './types';
-import { TypedArrayParser } from './typedArrayParsers';
-import { TypedArrayLoader } from './TypedArrayLoader';
-import { TypedArray } from './typedArray';
-import { Class, WritableKeysOf } from 'type-fest';
 import { Data3DTexture, DataTexture, Loader } from 'three';
-
+import { Class, WritableKeysOf } from 'type-fest';
+import { TypedArray } from './typedArray';
+import { TypedArrayLoader } from './TypedArrayLoader';
+import { TypedArrayParser } from './typedArrayParsers';
+import { Callable } from './types';
 type ParameterProperties<T> = {
     [K in WritableKeysOf<T> as T[K] extends Callable ? never : K]: T[K];
 };

package/types/EXR3DLoader.d.ts

@@ -1,5 +1,4 @@
 import { Data3DTexture, Loader } from 'three';
-
 export declare class EXR3DLoader extends Loader<Data3DTexture> {
     depth?: number;
     setDepth(value: number): this;

package/types/Ellipsoid.d.ts

@@ -1,6 +1,5 @@
-import { ProjectOnEllipsoidSurfaceOptions } from './helpers/projectOnEllipsoidSurface';
 import { Matrix4, Vector3, Ray } from 'three';
-
+import { ProjectOnEllipsoidSurfaceOptions } from './helpers/projectOnEllipsoidSurface';
 export declare class Ellipsoid {
     static readonly WGS84: Ellipsoid;
     readonly radii: Vector3;

package/types/EllipsoidGeometry.d.ts

@@ -1,5 +1,4 @@
 import { BufferGeometry, Vector3 } from 'three';
-
 export interface EllipsoidGeometryParameters {
     radii: Vector3;
     longitudeSegments?: number;

package/types/Geodetic.d.ts

@@ -1,7 +1,6 @@
-import { ProjectOnEllipsoidSurfaceOptions } from './helpers/projectOnEllipsoidSurface';
-import { Ellipsoid } from './Ellipsoid';
 import { Vector3 } from 'three';
-
+import { Ellipsoid } from './Ellipsoid';
+import { ProjectOnEllipsoidSurfaceOptions } from './helpers/projectOnEllipsoidSurface';
 export type GeodeticTuple = [number, number, number];
 export interface GeodeticLike {
     readonly longitude: number;

package/types/PointOfView.d.ts

@@ -1,6 +1,5 @@
-import { Ellipsoid } from './Ellipsoid';
 import { Quaternion, Vector3, Camera } from 'three';
-
+import { Ellipsoid } from './Ellipsoid';
 export declare class PointOfView {
     private _distance;
     heading: number;

package/types/Rectangle.d.ts

@@ -1,5 +1,4 @@
 import { Geodetic } from './Geodetic';
-
 export type RectangleTuple = [number, number, number, number];
 export interface RectangleLike {
     readonly west: number;

package/types/Texture3DLoader.d.ts

@@ -1,5 +1,4 @@
 import { Data3DTexture, Loader } from 'three';
-
 export declare class Texture3DLoader extends Loader<Data3DTexture> {
     load(url: string, onLoad: (data: Data3DTexture) => void, onProgress?: (event: ProgressEvent) => void, onError?: (error: unknown) => void): void;
 }

package/types/TilingScheme.d.ts

@@ -1,8 +1,7 @@
-import { TileCoordinate, TileCoordinateLike } from './TileCoordinate';
-import { Rectangle, RectangleLike } from './Rectangle';
-import { GeodeticLike } from './Geodetic';
 import { Vector2 } from 'three';
-
+import { GeodeticLike } from './Geodetic';
+import { Rectangle, RectangleLike } from './Rectangle';
+import { TileCoordinate, TileCoordinateLike } from './TileCoordinate';
 export interface TilingSchemeLike {
     readonly width: number;
     readonly height: number;

package/types/TypedArrayLoader.d.ts

@@ -1,17 +1,10 @@
-import { TypedArrayParser } from './typedArrayParsers';
-import { TypedArray } from './typedArray';
-import { Class } from 'type-fest';
 import { Loader } from 'three';
-
+import { Class } from 'type-fest';
+import { TypedArray } from './typedArray';
+import { TypedArrayParser } from './typedArrayParsers';
 export declare abstract class TypedArrayLoader<T extends TypedArray> extends Loader<T> {
     abstract parseTypedArray(buffer: ArrayBuffer): T;
     load(url: string, onLoad: (data: T) => void, onProgress?: (event: ProgressEvent) => void, onError?: (error: unknown) => void): void;
 }
 export declare function createTypedArrayLoaderClass<T extends TypedArray>(parser: TypedArrayParser<T>): Class<TypedArrayLoader<T>>;
 export declare function createTypedArrayLoader<T extends TypedArray>(parser: TypedArrayParser<T>): TypedArrayLoader<T>;
-/** @deprecated Use createTypedArrayLoaderClass instead. */
-export declare const Int16ArrayLoader: Class<TypedArrayLoader<Int16Array<ArrayBufferLike>>>;
-/** @deprecated Use createTypedArrayLoaderClass instead. */
-export declare const Uint16ArrayLoader: Class<TypedArrayLoader<Uint16Array<ArrayBufferLike>>>;
-/** @deprecated Use createTypedArrayLoaderClass instead. */
-export declare const Float32ArrayLoader: Class<TypedArrayLoader<Float32Array<ArrayBufferLike>>>;

package/types/bufferGeometry.d.ts

@@ -1,6 +1,23 @@
-import { BufferGeometry } from 'three';
-
-export interface BufferGeometryLike extends Pick<BufferGeometry, 'attributes' | 'index' | 'boundingBox' | 'boundingSphere'> {
+import { BufferGeometry, TypedArray, Vector3Like } from 'three';
+export interface BufferGeometryLike {
+    attributes: Record<string, {
+        array: TypedArray;
+        itemSize: number;
+        normalized?: boolean;
+    }>;
+    index?: {
+        array: TypedArray;
+        itemSize: number;
+        normalized?: boolean;
+    } | null;
+    boundingBox?: {
+        min: Vector3Like;
+        max: Vector3Like;
+    } | null;
+    boundingSphere?: {
+        center: Vector3Like;
+        radius: number;
+    } | null;
 }
 export declare function toBufferGeometryLike(geometry: BufferGeometry): [BufferGeometryLike, ArrayBuffer[]];
 export declare function fromBufferGeometryLike(input: BufferGeometryLike, result?: BufferGeometry<import('three').NormalBufferAttributes>): BufferGeometry;

package/types/decorators.d.ts

@@ -1,5 +1,4 @@
 import { Material } from 'three';
-
 interface EffectLike {
     defines: Map<string, string>;
 }

package/types/defineShorthand.d.ts

@@ -1,5 +1,4 @@
 import { Uniform } from 'three';
-
 export type PropertyShorthand<Args extends readonly unknown[]> = Args extends readonly [infer T, infer K, ...infer Rest] ? K extends readonly string[] ? K[number] extends keyof T ? Rest extends readonly unknown[] ? {
     [P in K[number]]: T[P];
 } & PropertyShorthand<Rest> : {

package/types/helpers/projectOnEllipsoidSurface.d.ts

@@ -1,5 +1,4 @@
 import { Vector3 } from 'three';
-
 export interface ProjectOnEllipsoidSurfaceOptions {
     centerTolerance?: number;
 }

package/types/r3f/EastNorthUpFrame.d.ts

@@ -1,9 +1,8 @@
-import { GeodeticLike } from '../Geodetic';
-import { Ellipsoid } from '../Ellipsoid';
-import { SetOptional } from 'type-fest';
-import { Group } from 'three';
 import { ReactNode } from 'react';
-
+import { Group } from 'three';
+import { SetOptional } from 'type-fest';
+import { Ellipsoid } from '../Ellipsoid';
+import { GeodeticLike } from '../Geodetic';
 declare class EastNorthUpFrameGroup extends Group {
     set(longitude: number, latitude: number, height: number, ellipsoid?: Ellipsoid): void;
 }

package/types/r3f/EllipsoidMesh.d.ts

@@ -1,13 +1,12 @@
-import { EllipsoidGeometry } from '../EllipsoidGeometry';
+import { ElementProps, ThreeElement } from '@react-three/fiber';
 import { Mesh } from 'three';
-import { BufferGeometryNode, MeshProps } from '@react-three/fiber';
-
+import { EllipsoidGeometry } from '../EllipsoidGeometry';
 declare module '@react-three/fiber' {
     interface ThreeElements {
-        ellipsoidGeometry: BufferGeometryNode<EllipsoidGeometry, typeof EllipsoidGeometry>;
+        ellipsoidGeometry: ThreeElement<typeof EllipsoidGeometry>;
     }
 }
-export interface EllipsoidMeshProps extends Omit<MeshProps, 'args'> {
+export interface EllipsoidMeshProps extends Omit<ElementProps<typeof Mesh>, 'args'> {
     args?: ConstructorParameters<typeof EllipsoidGeometry>;
 }
 export declare const EllipsoidMesh: import('react').ForwardRefExoticComponent<Omit<EllipsoidMeshProps, "ref"> & import('react').RefAttributes<Mesh<import('three').BufferGeometry<import('three').NormalBufferAttributes>, import('three').Material | import('three').Material[], import('three').Object3DEventMap>>>;

package/types/r3f/types.d.ts

@@ -1,21 +1,7 @@
-import { Callable } from '../types';
-import { WritableKeysOf } from 'type-fest';
-import { Color as ColorImpl, Vector2 as Vector2Impl, Vector3 as Vector3Impl, Vector4 as Vector4Impl } from 'three';
-import { NodeProps, Overwrite, Color as R3FColor, Vector2 as R3FVector2, Vector3 as R3FVector3, Vector4 as R3FVector4 } from '@react-three/fiber';
-
-export type ExtendedProps<T> = {
-    [K in keyof T]: Vector2Impl extends T[K] ? R3FVector2 | T[K] : Vector3Impl extends T[K] ? R3FVector3 | T[K] : Vector4Impl extends T[K] ? R3FVector4 | T[K] : ColorImpl extends T[K] ? R3FColor | T[K] : T[K];
+import { MathType, MathTypes } from '@react-three/fiber';
+export type OverwriteMathProps<T> = {
+    [K in keyof T]: Exclude<T[K], undefined> extends MathTypes ? T[K] extends undefined ? MathType<Exclude<T[K], undefined>> | undefined : MathType<Exclude<T[K], undefined>> : T[K];
 };
-type NonFunctionKeys<T> = keyof {
-    [K in keyof T as Callable extends T[K] ? never : K]: any;
-};
-type WritableNonExtendableKeysOf<T> = WritableKeysOf<T> | keyof {
-    [K in keyof T as Vector2Impl extends T[K] ? K : Vector3Impl extends T[K] ? K : Vector4Impl extends T[K] ? K : ColorImpl extends T[K] ? K : never]: any;
-};
-export type PassThoughInstanceProps<RefType, Args extends readonly any[], Props> = Overwrite<ExtendedProps<{
-    [K in NonFunctionKeys<Props> as K extends WritableNonExtendableKeysOf<Props> ? K : never]: Props[K];
-}>, NodeProps<RefType, Args>>;
 export type ExpandNestedProps<T, Prop extends keyof T & string> = {
     [K in keyof NonNullable<T[Prop]> as K extends string ? `${Prop}-${K}` : 'never']: NonNullable<T[Prop]>[K];
 };
-export {};

package/types/typedArray.d.ts

@@ -1,10 +1,5 @@
 import { Float16Array, Float16ArrayConstructor } from '@petamoriken/float16';
-
 export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float16Array | Float32Array | Float64Array;
 export type TypedArrayConstructor = Int8ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float16ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor;
-/** @deprecated */
-export type TypedArrayElementType = 'int8' | 'uint8' | 'int16' | 'uint16' | 'int32' | 'uint32' | 'float16' | 'float32' | 'float64';
-/** @deprecated Use getTypedArrayTextureDataType instead */
-export declare function getTypedArrayElementType(array: TypedArray): TypedArrayElementType;
 export declare function isTypedArray(value: unknown): value is TypedArray;
 export { Float16Array };

package/types/typedArrayParsers.d.ts

@@ -1,6 +1,5 @@
-import { TypedArray } from './typedArray';
 import { Float16Array } from '@petamoriken/float16';
-
+import { TypedArray } from './typedArray';
 export type TypedArrayParser<T extends TypedArray> = (buffer: ArrayBuffer, littleEndian?: boolean) => T;
 export declare const parseUint8Array: TypedArrayParser<Uint8Array>;
 export declare const parseInt8Array: TypedArrayParser<Int8Array>;

package/types/types.d.ts

@@ -1,5 +1,4 @@
 import { Uniform } from 'three';
-
 export type Callable = (...args: any) => any;
 export type UniformMap<T> = Omit<Map<string, Uniform>, 'get'> & {
     get: <K extends keyof T>(key: K) => T[K];