@thi.ng/api 8.3.8 → 8.4.1

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2022-07-19T15:36:12Z
+- **Last updated**: 2022-08-23T10:37:04Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -9,6 +9,16 @@ See [Conventional Commits](https://conventionalcommits.org/) for commit guidelin
 **Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
 and/or version bumps of transitive dependencies.
 
+## [8.4.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/api@8.4.0) (2022-08-15)
+
+#### 🚀 Features
+
+- add i64/u64 support for typed arrays ([0bb5277](https://github.com/thi-ng/umbrella/commit/0bb5277))
+  - add various 64bit bigint related types & lookups
+  - add BIT_SHIFTS LUT
+  - update sizeOf()
+  - update typedArray()
+
 ## [8.3.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/api@8.3.0) (2021-11-17)
 
 #### 🚀 Features

package/README.md

@@ -60,7 +60,7 @@ node --experimental-repl-await
 > const api = await import("@thi.ng/api");
 ```
 
-Package sizes (gzipped, pre-treeshake): ESM: 2.25 KB
+Package sizes (gzipped, pre-treeshake): ESM: 2.33 KB
 
 ## Dependencies
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/api",
-  "version": "8.3.8",
+  "version": "8.4.1",
   "description": "Common, generic types, interfaces & mixins",
   "type": "module",
   "module": "./index.js",
@@ -35,7 +35,7 @@
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.25.0",
-    "@thi.ng/testament": "^0.2.9",
+    "@thi.ng/testament": "^0.2.12",
     "rimraf": "^3.0.2",
     "tools": "^0.0.1",
     "typedoc": "^0.22.17",
@@ -222,5 +222,5 @@
       "default": "./watch.js"
     }
   },
-  "gitHead": "108a6357b77d457912d30681d7cc5603ae995209\n"
+  "gitHead": "be8423e2019e95c14a096260a93b9762dde0c768\n"
 }

package/typedarray.d.ts

@@ -1,12 +1,14 @@
 export declare type ArrayLikeIterable<T> = ArrayLike<T> & Iterable<T>;
 export declare type NumericArray = number[] | TypedArray;
 export declare type TypedArray = Float32Array | Float64Array | Int8Array | Int16Array | Int32Array | Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array;
+export declare type BigTypedArray = BigInt64Array | BigUint64Array;
 export declare type FloatArray = Float32Array | Float64Array;
 export declare type IntArray = Int8Array | Int16Array | Int32Array;
 export declare type UIntArray = Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array;
 export declare type FloatArrayConstructor = Float32ArrayConstructor | Float64ArrayConstructor;
 export declare type IntArrayConstructor = Int8ArrayConstructor | Int16ArrayConstructor | Int32ArrayConstructor;
 export declare type UIntArrayConstructor = Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor;
+export declare type BigIntArrayConstructor = BigInt64ArrayConstructor | BigUint64ArrayConstructor;
 export declare type TypedArrayConstructor = FloatArrayConstructor | IntArrayConstructor | UIntArrayConstructor;
 /**
  * Type IDs for typed array backed buffers and generally describing binary data
@@ -15,6 +17,7 @@ export declare type TypedArrayConstructor = FloatArrayConstructor | IntArrayCons
  * {@link GLType} {@link GL2TYPE} {@link TYPE2GL}
  */
 export declare type Type = "u8" | "u8c" | "i8" | "u16" | "i16" | "u32" | "i32" | "f32" | "f64";
+export declare type BigType = "i64" | "u64";
 export declare type UintType = "u8" | "u8c" | "u16" | "u32";
 export declare type IntType = "i8" | "i16" | "i32";
 export declare type FloatType = "f32" | "f64";
@@ -48,7 +51,8 @@ export declare const GL2TYPE: Record<GLType, Type>;
  */
 export declare const TYPE2GL: Record<Type, GLType | undefined>;
 /**
- * Size information (in bytes) for {@link Type}. Also see {@link sizeOf}.
+ * Size information (in bytes) for {@link Type} and {@link BigType}. Also see
+ * {@link sizeOf}.
  */
 export declare const SIZEOF: {
     u8: number;
@@ -58,12 +62,32 @@ export declare const SIZEOF: {
     i16: number;
     u32: number;
     i32: number;
+    i64: number;
+    u64: number;
+    f32: number;
+    f64: number;
+};
+/**
+ * Bit shift values to convert byte addresses into array indices for all
+ * {@link Type}s and {@link BigType}s.
+ */
+export declare const BIT_SHIFTS: {
+    i8: number;
+    u8: number;
+    u8c: number;
+    i16: number;
+    u16: number;
+    i32: number;
+    u32: number;
+    i64: number;
+    u64: number;
     f32: number;
     f64: number;
 };
 export declare const FLOAT_ARRAY_CTORS: Record<FloatType, FloatArrayConstructor>;
 export declare const INT_ARRAY_CTORS: Record<IntType, IntArrayConstructor>;
 export declare const UINT_ARRAY_CTORS: Record<UintType, UIntArrayConstructor>;
+export declare const BIGINT_ARRAY_CTORS: Record<BigType, BigIntArrayConstructor>;
 export declare const TYPEDARRAY_CTORS: Record<Type, TypedArrayConstructor>;
 export interface TypedArrayTypeMap extends Record<Type | GLType, TypedArray> {
     u8: Uint8Array;
@@ -83,6 +107,10 @@ export interface TypedArrayTypeMap extends Record<Type | GLType, TypedArray> {
     [GLType.I32]: Int32Array;
     [GLType.F32]: Float32Array;
 }
+export interface BigTypedArrayTypeMap extends Record<BigType, BigTypedArray> {
+    i64: BigInt64Array;
+    u64: BigUint64Array;
+}
 /**
  * Returns canonical {@link Type} value of `type` by first
  * attempting to resolve it as {@link GLType} enum.
@@ -117,16 +145,19 @@ export declare const asInt: (...args: number[]) => number[];
  *
  * @param type -
  */
-export declare const sizeOf: (type: GLType | Type) => number;
+export declare const sizeOf: (type: Type | BigType | GLType) => number;
 /**
- * Constructs new typed array of given {@link Type}/{@link GLType}. Supports all
- * arities of standard typed array ctors.
+ * Constructs new typed array of given {@link Type}, {@link GLType} or
+ * {@link BigType}. Supports all arities of standard typed array ctors.
  *
  * @param type - array type enum
  */
 export declare function typedArray<T extends Type | GLType>(type: T, length: number): TypedArrayTypeMap[T];
 export declare function typedArray<T extends Type | GLType>(type: T, src: ArrayLike<number> | ArrayBufferLike): TypedArrayTypeMap[T];
 export declare function typedArray<T extends Type | GLType>(type: T, buf: ArrayBufferLike, byteOffset: number, length?: number): TypedArrayTypeMap[T];
+export declare function typedArray<T extends BigType>(type: T, length: number): BigTypedArrayTypeMap[T];
+export declare function typedArray<T extends BigType>(type: T, src: ArrayLike<bigint> | ArrayBufferLike): BigTypedArrayTypeMap[T];
+export declare function typedArray<T extends BigType>(type: T, buf: ArrayBufferLike, byteOffset: number, length?: number): BigTypedArrayTypeMap[T];
 /**
  * Takes an {@link NumericArray} and returns its corresponding {@link Type} ID.
  * Standard JS arrays will default to {@link "f64"}.

package/typedarray.js

@@ -47,7 +47,8 @@ export const TYPE2GL = {
     f64: undefined,
 };
 /**
- * Size information (in bytes) for {@link Type}. Also see {@link sizeOf}.
+ * Size information (in bytes) for {@link Type} and {@link BigType}. Also see
+ * {@link sizeOf}.
  */
 export const SIZEOF = {
     u8: 1,
@@ -57,9 +58,28 @@ export const SIZEOF = {
     i16: 2,
     u32: 4,
     i32: 4,
+    i64: 8,
+    u64: 8,
     f32: 4,
     f64: 8,
 };
+/**
+ * Bit shift values to convert byte addresses into array indices for all
+ * {@link Type}s and {@link BigType}s.
+ */
+export const BIT_SHIFTS = {
+    i8: 0,
+    u8: 0,
+    u8c: 0,
+    i16: 1,
+    u16: 1,
+    i32: 2,
+    u32: 2,
+    i64: 3,
+    u64: 3,
+    f32: 2,
+    f64: 2,
+};
 export const FLOAT_ARRAY_CTORS = {
     f32: Float32Array,
     f64: Float64Array,
@@ -75,6 +95,10 @@ export const UINT_ARRAY_CTORS = {
     u16: Uint16Array,
     u32: Uint32Array,
 };
+export const BIGINT_ARRAY_CTORS = {
+    i64: BigInt64Array,
+    u64: BigUint64Array,
+};
 export const TYPEDARRAY_CTORS = {
     ...FLOAT_ARRAY_CTORS,
     ...INT_ARRAY_CTORS,
@@ -120,9 +144,10 @@ export const asInt = (...args) => args.map((x) => x | 0);
  *
  * @param type -
  */
-export const sizeOf = (type) => SIZEOF[asNativeType(type)];
+export const sizeOf = (type) => SIZEOF[type] || SIZEOF[asNativeType(type)];
 export function typedArray(type, ...xs) {
-    return new TYPEDARRAY_CTORS[asNativeType(type)](...xs);
+    const ctor = BIGINT_ARRAY_CTORS[type];
+    return new (ctor || TYPEDARRAY_CTORS[asNativeType(type)])(...xs);
 }
 /**
  * Takes an {@link NumericArray} and returns its corresponding {@link Type} ID.