@takram/three-geospatial 0.0.1-alpha.5 → 0.0.1-alpha.7

package/types/DataLoader.d.ts

@@ -27,11 +27,11 @@ export declare function createDataTextureLoaderClass<T extends TypedArray>(parse
 export declare function createData3DTextureLoader<T extends TypedArray>(parser: TypedArrayParser<T>, parameters?: Data3DTextureParameters): DataLoader<Data3DTexture, T>;
 export declare function createDataTextureLoader<T extends TypedArray>(parser: TypedArrayParser<T>, parameters?: DataTextureParameters): DataLoader<DataTexture, T>;
 /** @deprecated Use createDataTextureLoaderClass instead. */
-export declare const Int16Data2DLoader: Class<DataLoader<DataTexture, Int16Array>>;
+export declare const Int16Data2DLoader: Class<DataLoader<DataTexture, Int16Array<ArrayBufferLike>>>;
 /** @deprecated Use createDataTextureLoaderClass instead. */
-export declare const Uint16Data2DLoader: Class<DataLoader<DataTexture, Uint16Array>>;
+export declare const Uint16Data2DLoader: Class<DataLoader<DataTexture, Uint16Array<ArrayBufferLike>>>;
 /** @deprecated Use createDataTextureLoaderClass instead. */
-export declare const Float32Data2DLoader: Class<DataLoader<DataTexture, Float32Array>>;
+export declare const Float32Data2DLoader: Class<DataLoader<DataTexture, Float32Array<ArrayBufferLike>>>;
 /** @deprecated Use createData3DTextureLoaderClass instead. */
-export declare const Float32Data3DLoader: Class<DataLoader<Data3DTexture, Float32Array>>;
+export declare const Float32Data3DLoader: Class<DataLoader<Data3DTexture, Float32Array<ArrayBufferLike>>>;
 export {};

package/types/STBNLoader.d.ts

@@ -0,0 +1 @@
+export declare const STBNLoader: import('type-fest').Class<import('./DataLoader').DataLoader<import('three').Data3DTexture, Uint8Array<ArrayBufferLike>>>;

package/types/Texture3DLoader.d.ts

@@ -0,0 +1,5 @@
+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/TypedArrayLoader.d.ts

@@ -9,8 +9,8 @@ export declare abstract class TypedArrayLoader<T extends TypedArray> extends Loa
 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>>;
+export declare const Int16ArrayLoader: Class<TypedArrayLoader<Int16Array<ArrayBufferLike>>>;
 /** @deprecated Use createTypedArrayLoaderClass instead. */
-export declare const Uint16ArrayLoader: Class<TypedArrayLoader<Uint16Array>>;
+export declare const Uint16ArrayLoader: Class<TypedArrayLoader<Uint16Array<ArrayBufferLike>>>;
 /** @deprecated Use createTypedArrayLoaderClass instead. */
-export declare const Float32ArrayLoader: Class<TypedArrayLoader<Float32Array>>;
+export declare const Float32ArrayLoader: Class<TypedArrayLoader<Float32Array<ArrayBufferLike>>>;

package/types/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const STBN_TEXTURE_WIDTH = 128;
+export declare const STBN_TEXTURE_HEIGHT = 128;
+export declare const STBN_TEXTURE_DEPTH = 64;
+export declare const DEFAULT_STBN_URL = "https://media.githubusercontent.com/media/takram-design-engineering/three-geospatial/9627216cc50057994c98a2118f3c4a23765d43b9/packages/core/assets/stbn.bin";

package/types/defineShorthand.d.ts

@@ -0,0 +1,16 @@
+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> : {
+    [P in K[number]]: T[P];
+} : never : never : {};
+export declare function definePropertyShorthand<T, Args extends readonly unknown[]>(destination: T, ...sourceKeysArgs: [...Args]): T & PropertyShorthand<Args>;
+export type UniformShorthand<T extends {
+    uniforms: Record<K, Uniform>;
+}, K extends keyof T['uniforms']> = {
+    [P in K]: T['uniforms'][P] extends Uniform<infer U> ? U : never;
+};
+export declare function defineUniformShorthand<T, S extends {
+    uniforms: Record<K, Uniform>;
+}, K extends keyof S['uniforms']>(destination: T, source: S, keys: readonly K[]): T & UniformShorthand<S, K>;

package/types/index.d.ts

@@ -1,19 +1,21 @@
-export declare const depthShader: string;
-export declare const packingShader: string;
-export declare const transformShader: string;
 export * from './ArrayBufferLoader';
 export * from './assertions';
 export * from './bufferGeometry';
+export * from './constants';
 export * from './DataLoader';
+export * from './defineShorthand';
 export * from './Ellipsoid';
 export * from './EllipsoidGeometry';
 export * from './Geodetic';
 export * from './math';
 export * from './PointOfView';
 export * from './Rectangle';
+export * from './resolveIncludes';
+export * from './STBNLoader';
 export * from './TileCoordinate';
 export * from './TilingScheme';
 export * from './typedArray';
 export * from './TypedArrayLoader';
 export * from './typedArrayParsers';
 export * from './types';
+export * from './unrollLoops';

package/types/math.d.ts

@@ -8,7 +8,10 @@ export declare const isPowerOfTwo: typeof import('three/src/math/MathUtils.js').
 export declare const ceilPowerOfTwo: typeof import('three/src/math/MathUtils.js').ceilPowerOfTwo;
 export declare const floorPowerOfTwo: typeof import('three/src/math/MathUtils.js').floorPowerOfTwo;
 export declare const normalize: typeof import('three/src/math/MathUtils.js').normalize;
-export declare const remap: typeof import('three/src/math/MathUtils.js').mapLinear;
+export declare function remap(x: number, min1: number, max1: number): number;
+export declare function remap(x: number, min1: number, max1: number, min2: number, max2: number): number;
+export declare function remapClamped(x: number, min1: number, max1: number): number;
+export declare function remapClamped(x: number, min1: number, max1: number, min2: number, max2: number): number;
 export declare function smoothstep(min: number, max: number, x: number): number;
 export declare function saturate(x: number): number;
 export declare function closeTo(a: number, b: number, relativeEpsilon: number, absoluteEpsilon?: number): boolean;

package/types/r3f/index.d.ts

@@ -1,2 +1,3 @@
 export * from './EastNorthUpFrame';
 export * from './EllipsoidMesh';
+export * from './types';

package/types/r3f/types.d.ts

@@ -0,0 +1,21 @@
+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];
+};
+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 T[Prop] as K extends string ? `${Prop}-${K}` : never]: T[Prop][K];
+};
+export {};

package/types/resolveIncludes.d.ts

@@ -0,0 +1,5 @@
+interface Includes {
+    [key: string]: string | Includes;
+}
+export declare function resolveIncludes(source: string, includes: Includes): string;
+export {};

package/types/shaders/index.d.ts

@@ -0,0 +1,9 @@
+export declare const cascadedShadowMaps: string;
+export declare const depth: string;
+export declare const generators: string;
+export declare const math: string;
+export declare const packing: string;
+export declare const poissonDisk: string;
+export declare const raySphereIntersection: string;
+export declare const transform: string;
+export declare const turbo: string;

package/types/types.d.ts

@@ -1,22 +1,7 @@
-import { ReadonlyTuple } from 'type-fest';
-import { Matrix2, Matrix3, Matrix4, Vector2, Vector3, Vector4 } from 'three';
+import { Uniform } from 'three';
 
 export type Callable = (...args: any) => any;
-export type ReadonlyTuple2<T = number> = ReadonlyTuple<T, 2>;
-export type ReadonlyTuple3<T = number> = ReadonlyTuple<T, 3>;
-export type ReadonlyTuple4<T = number> = ReadonlyTuple<T, 4>;
-type BuildTupleHelper<Element, Length extends number, Rest extends Element[]> = Rest['length'] extends Length ? [...Rest] : BuildTupleHelper<Element, Length, [Element, ...Rest]>;
-export type Tuple<T, Length extends number> = number extends Length ? readonly T[] : BuildTupleHelper<T, Length, []>;
-export type Tuple2<T = number> = BuildTupleHelper<T, 2, []>;
-export type Tuple3<T = number> = BuildTupleHelper<T, 3, []>;
-export type Tuple4<T = number> = BuildTupleHelper<T, 4, []>;
-type ReadonlyThreeInstance<T> = Readonly<{
-    [K in keyof T as T[K] extends Callable ? ReturnType<T[K]> extends T ? K extends 'clone' ? K : never : K : K]: T[K];
-}>;
-export type ReadonlyVector2 = ReadonlyThreeInstance<Vector2>;
-export type ReadonlyVector3 = ReadonlyThreeInstance<Vector3>;
-export type ReadonlyVector4 = ReadonlyThreeInstance<Vector4>;
-export type ReadonlyMatrix2 = ReadonlyThreeInstance<Matrix2>;
-export type ReadonlyMatrix3 = ReadonlyThreeInstance<Matrix3>;
-export type ReadonlyMatrix4 = ReadonlyThreeInstance<Matrix4>;
-export {};
+export type UniformMap<T> = Omit<Map<string, Uniform>, 'get'> & {
+    get: <K extends keyof T>(key: K) => T[K];
+    set: <K extends keyof T>(key: K, value: T[K]) => void;
+};

package/types/unrollLoops.d.ts

@@ -0,0 +1 @@
+export declare function unrollLoops(string: string): string;