@pirireis/webglobeplugins 0.9.3 → 0.9.4

package/Math/juction/arc-plane.ts

@@ -15,7 +15,17 @@ const _originSphere = /*@__PURE__*/ { center: vec3.create(0, 0, 0), radius: 1 }
 const _intersectionPoints: [Vec3, Vec3] = /*@__PURE__*/[vec3.create(), vec3.create()];
 
 // TODO: out must be [Arc, Arc] there is a case where split into three arcs, visible by points or arcs but middle is not visible
-export function arcSlice(out: Arc, inArc: Arc, juctionPlane: Plane): boolean {
+
+
+
+/**
+ * 
+ * @param out \
+ * @param inArc 
+ * @param juctionPlane 
+ * @returns number of arcs segments in the junction divided by the junction plane.
+ */
+export function arcSlice(out: [Arc, Arc], inArc: Arc, juctionPlane: Plane): number {
 
     // arc coverPlane and junctionPlane intersection exist in the range of unit sphere
     const coverRadiusAngle = plane.getUnitSphereRadiusAngle(inArc.coverPlane);
@@ -24,15 +34,15 @@ export function arcSlice(out: Arc, inArc: Arc, juctionPlane: Plane): boolean {
     const angleBetween_Cover_Visible = Math.acos(vec3.dot(inArc.coverPlane.normal, juctionPlane.normal));
 
     if (coverRadiusAngle + visibleRadiusAngle < angleBetween_Cover_Visible - EPSILON) { // case A: out of range
-        return false; // No intersection
+        return 0; // No intersection
     }
     // ------------------------------------
 
     // the case when the arc is completely covered by the juction plane
 
     if (visibleRadiusAngle + EPSILON >= angleBetween_Cover_Visible + coverRadiusAngle) { // case B: fully visible
-        arc.copy(out, inArc);
-        return true;
+        arc.copy(out[0], inArc);
+        return 1;
     }
     // plane-plane intersection line should be calculated for the rest of the calculations
 
@@ -44,7 +54,7 @@ export function arcSlice(out: Arc, inArc: Arc, juctionPlane: Plane): boolean {
         // case B Covers they face each other
         throw new Error("Unexpected case: planes are parallel, case A and B should Cover it");
     }
-
+    // --- read until here ---
 
     // calculate the intersection points
 
@@ -52,28 +62,41 @@ export function arcSlice(out: Arc, inArc: Arc, juctionPlane: Plane): boolean {
 
     if (!isSphereIntersection) {
         // other edge caes should be covered by now
-        return false; // No intersection
+        return 0; // No intersection
     }
 
 
     const i0IsCovered = plane.distanceToPoint(inArc.coverPlane, _intersectionPoints[0]) > -EPSILON;
     const i1IsCovered = plane.distanceToPoint(inArc.coverPlane, _intersectionPoints[1]) > -EPSILON;
 
-    if (i0IsCovered && i1IsCovered) {
-        arc.set(out, _intersectionPoints[0], _intersectionPoints[1]);
-        return true;
-    }
 
     const p0IsVisible = plane.distanceToPoint(juctionPlane, inArc.p0) > -EPSILON;
     const p1IsVisible = plane.distanceToPoint(juctionPlane, inArc.p1) > -EPSILON;
 
-    if (p0IsVisible && p1IsVisible) {
-        arc.copy(out, inArc);
-        return true;
+    if (!p0IsVisible && !p1IsVisible && !i0IsCovered && !i1IsCovered) {
+        return 0; // No intersection
     }
 
-    if (!p0IsVisible && !p1IsVisible && !i0IsCovered && !i1IsCovered) {
-        return false; // No intersection
+    if (i0IsCovered && i1IsCovered && p0IsVisible && p1IsVisible) {
+        // calculate which points are closer
+        const p0i0DistanceSquared = vec3.distanceSquared(inArc.p0, _intersectionPoints[0]);
+        const p0i1DistanceSquared = vec3.distanceSquared(inArc.p0, _intersectionPoints[1]);
+        const case0 = p0i0DistanceSquared < p0i1DistanceSquared;
+        arc.set(out[0], inArc.p0, case0 ? _intersectionPoints[0] : _intersectionPoints[1]);
+        arc.set(out[1], inArc.p1, !case0 ? _intersectionPoints[0] : _intersectionPoints[1]);
+        return 2;
+    }
+
+
+    if (i0IsCovered && i1IsCovered) {
+        arc.set(out[0], _intersectionPoints[0], _intersectionPoints[1]);
+        return 1;
+    }
+
+
+    if (p0IsVisible && p1IsVisible) {
+        arc.copy(out[0], inArc);
+        return 1;
     }
 
     if ((p0IsVisible || p1IsVisible) !== (i0IsCovered || i1IsCovered)) {
@@ -81,10 +104,11 @@ export function arcSlice(out: Arc, inArc: Arc, juctionPlane: Plane): boolean {
     }
 
     arc.set(
-        out,
+        out[0],
         p0IsVisible ? inArc.p0 : inArc.p1,
         i0IsCovered ? _intersectionPoints[0] : _intersectionPoints[1]
     );
 
-    return true;
-}
+    return 1;
+}
+

package/Math/quaternion.ts

@@ -56,7 +56,7 @@ export const quaternion = Object.freeze({
         const z = a[2] * b[3] + a[3] * b[2] + a[0] * b[1] - a[1] * b[0];
         const w = a[3] * b[3] - a[0] * b[0] - a[1] * b[1] - a[2] * b[2];
         this.set(out, x, y, z, w);
-        this.normalize(out);
+        this.normalize(out, out);
     },
 
     lengthSquared(a: Quaternion): number {
@@ -67,17 +67,14 @@ export const quaternion = Object.freeze({
         return Math.sqrt(this.lengthSquared(a));
     },
 
-    normalize(out: Quaternion) {
-        const len = Math.sqrt(this.lengthSquared(out));
+    normalize(out: Quaternion, input: Quaternion) {
+        const len = Math.sqrt(this.lengthSquared(input));
         if (len < EPSILON) {
             this.set(out, 0, 0, 0, 1);
         }
         else {
             const invLen = 1 / len;
-            out[0] *= invLen;
-            out[1] *= invLen;
-            out[2] *= invLen;
-            out[3] *= invLen;
+            this.set(out, input[0] * invLen, input[1] * invLen, input[2] * invLen, input[3] * invLen);
         }
     },
 
@@ -105,7 +102,7 @@ export const quaternion = Object.freeze({
         const z = from[2] * to[3] + from[3] * to[2] + from[0] * to[1] - from[1] * to[0];
         const w = from[3] * to[3] - from[0] * to[0] - from[1] * to[1] - from[2] * to[2];
         this.set(out, x, y, z, w);
-        this.normalize(out);
+        this.normalize(out, out);
     },
 
     conjugate(out: Quaternion, a: Quaternion) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pirireis/webglobeplugins",
-    "version": "0.9.3",
+    "version": "0.9.4",
     "main": "index.js",
     "author": "Toprak Nihat Deniz Ozturk",
     "license": "MIT"

package/programs/line-on-globe/linestrip.ts

@@ -14,7 +14,7 @@ import "../../util/gl-util/buffer/attribute-loader";
 import { UniformBlockManager } from "../../util/gl-util/uniform-block/manager";
 import "../../util/gl-util/uniform-block/types";
 
-import { drawArrays } from "../../util/gl-util/draw-options/methods.js";
+import { drawArrays } from "../../util/gl-util/draw-options/methods";
 import "../../util/gl-util/draw-options/types";
 
 
@@ -138,7 +138,7 @@ class Logic implements ProgramInterface {
         this.gl = globe.gl;
 
         this.globe = globe;
-        this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource);
+        this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource) as WebGLProgram;
         const currentProgram = this.gl.getParameter(this.gl.CURRENT_PROGRAM);
         this.gl.useProgram(this.program);
         this._opacity.location = this.gl.getUniformLocation(this.program, "opacity");

package/programs/{programcache.js → programcache.ts}

@@ -16,7 +16,7 @@ const globeProgramCache = (function () {
 
     const cache = new Map();
 
-    function getProgram(globe, ProgramClass) {
+    function getProgram(globe: any, ProgramClass: any) {
         if (!cache.has(globe)) { cache.set(globe, new Map()) };
         if (!cache.get(globe).has(ProgramClass)) {
             cache.get(globe).set(ProgramClass, {
@@ -31,7 +31,7 @@ const globeProgramCache = (function () {
         return cache.get(globe).get(ProgramClass).program;
     };
 
-    function releaseProgram(globe, ProgramClass) {
+    function releaseProgram(globe: any, ProgramClass: any) {
         if (cache.has(globe) && cache.get(globe).has(ProgramClass)) {
             if (cache.get(globe).get(ProgramClass).count === 0) {
                 throw new Error("The program counter is already 0, cannot release program");
@@ -56,7 +56,7 @@ const glProgramCache = (function () {
 
     const cache = new Map();
 
-    function getProgram(gl, ProgramClass) {
+    function getProgram(gl: WebGL2RenderingContext | WebGLRenderingContext, ProgramClass: any) {
         if (!cache.has(gl)) { cache.set(gl, new Map()) };
         if (!cache.get(gl).has(ProgramClass)) {
             cache.get(gl).set(ProgramClass, {
@@ -69,7 +69,7 @@ const glProgramCache = (function () {
         return cache.get(gl).get(ProgramClass).program;
     };
 
-    function releaseProgram(gl, ProgramClass) {
+    function releaseProgram(gl: WebGL2RenderingContext | WebGLRenderingContext, ProgramClass: any) {
         if (cache.has(gl) && cache.get(gl).has(ProgramClass)) {
             if (cache.get(gl).get(ProgramClass).count === 0) {
                 throw new Error("The program counter is already 0, cannot release program");
@@ -94,7 +94,7 @@ const noRegisterGlobeProgramCache = (function () {
 
     const cache = new Map();
 
-    function getProgram(globe, ProgramClass) {
+    function getProgram(globe: any, ProgramClass: any) {
         if (!cache.has(globe)) { cache.set(globe, new Map()) };
         if (!cache.get(globe).has(ProgramClass)) {
             cache.get(globe).set(ProgramClass, {
@@ -107,7 +107,7 @@ const noRegisterGlobeProgramCache = (function () {
         return cache.get(globe).get(ProgramClass).program;
     };
 
-    function releaseProgram(globe, ProgramClass) {
+    function releaseProgram(globe: any, ProgramClass: any) {
         if (cache.has(globe) && cache.get(globe).has(ProgramClass)) {
             if (cache.get(globe).get(ProgramClass).count === 0) {
                 throw new Error("The program counter is already 0, cannot release program");

package/programs/totems/camerauniformblock.d.ts

@@ -0,0 +1,48 @@
+export declare const CameraUniformBlockString: string;
+
+export default class CameraUniformBlockTotem {
+    id: string;
+    description: string;
+    gl: WebGL2RenderingContext | null;
+    globe: any;
+    ubo: WebGLBuffer | null;
+    // _frustumPlanes: any; // Uncomment and type if used
+    _isMovedParams: {
+        lastLod: number | null;
+        isMoved: boolean;
+    };
+    traslateFloat32: Float32Array;
+    mapWHFloat32: Float32Array;
+
+    constructor();
+
+    init(globe: any, gl: WebGL2RenderingContext): void;
+    resize(): void;
+    setGeometry(): void;
+    draw3D(
+        projection: Float32Array,
+        modelView: Float32Array,
+        translate: { x: number; y: number; z: number }
+    ): void;
+    assignBindingPoint(program: WebGLProgram, bindingPoint: number): void;
+    getUBO(): WebGLBuffer | null;
+    getFrustumPlanes(): any; // Update type if needed
+    bind(bindingPoint: number): void;
+    unbind(bindingPoint: number): void;
+    isMoved(): boolean;
+    free(): void;
+    readBuffer(): {
+        view: Float32Array;
+        projection: Float32Array;
+        translate: Float32Array;
+        is3D: number;
+        mapWH: Float32Array;
+        screenWH: Float32Array;
+        z_level: number;
+    };
+}
+
+export declare const CameraUniformBlockTotemCache: Readonly<{
+    get: (globe: any) => any;
+    release: (globe: any) => void;
+}>;

package/programs/vectorfields/logics/drawrectangleparticles.js

@@ -1,6 +1,6 @@
 import { createProgram } from "../../../util";
 import { UBO_BINDING_POINT, shaderUboSource } from "./ubo.js";
-import { glProgramCache } from "../../programcache.js";
+import { glProgramCache } from "../../programcache";
 /**
  * [+] ubo 
  */

package/tests/Math/junction/arc-plane.test.ts

@@ -1,4 +1,4 @@
-import { Plane, Line, Vec3, Quaternion } from '../../../Math/types';
+import { Plane, Line, Vec3, Quaternion, Arc } from '../../../Math/types';
 import { plane } from '../../../Math/plane';
 import { line } from '../../../Math/line';
 import { arc } from '../../../Math/arc';
@@ -10,7 +10,10 @@ import { EPSILON } from '../../../Math/constants';
 
 
 const arcIn = arc.create(vec3.create(0, 0, 1), vec3.create(1, 0, 0));
-const arcOut = arc.create(vec3.create(0, 0, 1), vec3.create(1, 0, 0));
+const arcOut: [Arc, Arc] = [
+    arc.create(vec3.create(0, 0, 1), vec3.create(1, 0, 0)),
+    arc.create(vec3.create(0, 0, 1), vec3.create(1, 0, 0))
+];
 const arcExpected = arc.create(vec3.create(0, 0, 1), vec3.create(1, 0, 0));
 const junctionPlane = plane.create(vec3.create(0, 0, 1), 0);
 
@@ -20,7 +23,8 @@ const r3 = Math.sqrt(3) / 3;
 beforeAll(() => {
     // Initialize any necessary data or state before running the tests
     arc.set(arcIn, vec3.create(0, 0, 1), vec3.create(1, 0, 0));
-    arc.set(arcOut, vec3.create(0, 0, 1), vec3.create(1, 0, 0));
+    arc.set(arcOut[0], vec3.create(0, 0, 1), vec3.create(1, 0, 0));
+    arc.set(arcOut[1], vec3.create(0, 0, 1), vec3.create(1, 0, 0));
 
     plane.set(junctionPlane, vec3.create(0, 0, 1), 0);
 
@@ -42,7 +46,7 @@ test('arcSlice - Full intersection 1', () => {
     junctionPlane.distance = 0; // Set distance to ensure full intersection
     const result = arcSlice(arcOut, arcIn, junctionPlane);
     expect(result).toBe(true);
-    const isEqual = arc.equals(arcOut, arcExpected);
+    const isEqual = arc.equals(arcOut[0], arcExpected);
     expect(isEqual).toBe(true);
 });
 
@@ -93,7 +97,7 @@ test("arcSlice - Planes are parallel", () => {
 
     const result2 = arcSlice(arcOut, arcIn, junctionPlane);
     expect(result2).toBe(true); // Expect no intersection
-    const isEqual = arc.equals(arcOut, arcIn);
+    const isEqual = arc.equals(arcOut[0], arcIn);
     expect(isEqual).toBe(true); // Expect the output arc to be equal to the input arc
 });
 
@@ -113,7 +117,7 @@ test("arcSlice - Arc sliced in half", () => {
     const expectedPoint1 = vec3.create(0, r2, r2);
     const expectedPoint2 = vec3.create(0, 0, 1);
     arc.set(arcExpected, expectedPoint1, expectedPoint2);
-    const isEqual = arc.equals(arcOut, arcExpected);
+    const isEqual = arc.equals(arcOut[0], arcExpected);
     expect(isEqual).toBe(true); // Expect the output arc to be equal to the expected arc
 });
 

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+    "compilerOptions": {
+        "target": "es2018",
+        "module": "commonjs",
+        "outDir": "./dist",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "allowJs": true,
+        "declaration": false
+    },
+    "include": [
+        "**/*.ts", // Include all .ts files in the current directory and subdirectories
+        "**/*.js" // Include all .js files in the current directory and subdirectories
+    ],
+    "exclude": [
+        "node_modules",
+        "dist" // Exclude the output directory itself
+    ]
+}

package/util/account/{index.ts → index.js}

@@ -1,4 +1,4 @@
-import BufferOffsetManager from './bufferoffsetmanager.js';
+import BufferOffsetManager from './bufferoffsetmanager';
 
 export { BufferOffsetManager };
 

package/util/account/single-attribute-buffer-management/{buffer-manager.js → buffer-manager.ts}

@@ -18,7 +18,13 @@
  */
 
 export class BufferManager {
-    constructor(gl, itemSize, { bufferType = "STATIC_DRAW", buffer = null, initialCapacity = null } = {}) {
+    gl: WebGL2RenderingContext;
+    buffer: WebGLBuffer;
+    itemSize: number;
+    bufferType: string;
+    isFreed: boolean = false;
+
+    constructor(gl: WebGL2RenderingContext, itemSize: number, { bufferType = "STATIC_DRAW", buffer = null, initialCapacity = null } = {}) {
         this.gl = gl;
         this.itemSize = itemSize;
         this.bufferType = bufferType;
@@ -26,14 +32,15 @@ export class BufferManager {
         if (initialCapacity !== null) this.resetWithCapacity(initialCapacity);
     }
 
-    resetWithCapacity(capacity) {
+    resetWithCapacity(capacity: number) {
         const { gl, buffer, bufferType, itemSize } = this;
         gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        // @ts-ignore
         gl.bufferData(gl.ARRAY_BUFFER, capacity * itemSize * 4, gl[bufferType]);
         gl.bindBuffer(gl.ARRAY_BUFFER, null);
     }
 
-    deleteBulk(offsets) {
+    deleteBulk(offsets: number[]) {
         const { gl, buffer, itemSize } = this;
         const emptyBlock = new Float32Array(this.itemSize).fill(NaN)
         const offsetMultiplier = itemSize * 4;
@@ -47,7 +54,7 @@ export class BufferManager {
     }
 
 
-    insertBulk(blocks, offsets) {
+    insertBulk(blocks: any[], offsets: number[]) {
         const { gl, buffer, itemSize } = this;
         gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
         const offsetMultiplier = itemSize * 4;
@@ -61,7 +68,7 @@ export class BufferManager {
 
 
     // TODO: this is broken
-    defrag(offsetValues, occupiedCapacity, newCapacity) {
+    defrag(offsetValues: MapIterator<number> | number[], occupiedCapacity: number, newCapacity: number) {
         const { gl, buffer, bufferType, itemSize } = this;
 
         const newArray = new Float32Array(newCapacity * itemSize);
@@ -74,23 +81,25 @@ export class BufferManager {
         }
 
         gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        // @ts-ignore
         gl.bufferData(gl.ARRAY_BUFFER, newCapacity * itemSize * 4, gl[bufferType]);
         gl.bufferSubData(gl.ARRAY_BUFFER, 0, newArray);
         gl.bindBuffer(gl.ARRAY_BUFFER, null);
 
     }
 
-    extendBuffer(occupiedCapacity, newCapacity) {
+    extendBuffer(occupiedCapacity: number, newCapacity: number) {
         const { gl, buffer, bufferType } = this;
         const itemSize = this.itemSize;
         const bufferData = this._getBufferData(occupiedCapacity);
         gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        // @ts-ignore
         gl.bufferData(gl.ARRAY_BUFFER, newCapacity * itemSize * 4, gl[bufferType]);
         gl.bufferSubData(gl.ARRAY_BUFFER, 0, bufferData);
         gl.bindBuffer(gl.ARRAY_BUFFER, null);
     }
 
-    _getBufferData(occupiedCapacity) {
+    _getBufferData(occupiedCapacity: number): Float32Array {
         const { gl, buffer } = this;
         const size = occupiedCapacity * this.itemSize;
         const bufferData = new Float32Array(size);
@@ -103,8 +112,8 @@ export class BufferManager {
     free() {
         if (this.isFreed) return;
         this.gl.deleteBuffer(this.buffer);
-        this.buffer = null;
-        this.gl = null;
+        // this.buffer = null;
+        // this.gl = null;
         this.isFreed = true;
     }
 }

package/util/account/single-attribute-buffer-management/{buffer-orchestrator.js → buffer-orchestrator.ts}

@@ -1,6 +1,12 @@
+import { BufferOrchestrator as BufferOrchestratorI, BufferManagersMap, BufferManager } from "./types";
+
 const EXTRA_SIZE = 10;
 
-export class BufferOrchestrator {
+export class BufferOrchestrator implements BufferOrchestratorI {
+    _capacity: number;
+    offsetMap: Map<string, number>;
+    tombstoneOffsets: number[];
+    _length: number;
 
     constructor({ capacity = 10 } = {}) {
         this._capacity = capacity;
@@ -10,7 +16,7 @@ export class BufferOrchestrator {
     }
 
 
-    resetWithCapacity(bufferManagersMap, capacity = null) {
+    resetWithCapacity(bufferManagersMap: BufferManagersMap, capacity: number | null = null) {
         this._capacity = capacity !== null ? capacity : this._capacity;
         for (const [key, { bufferManager }] of bufferManagersMap) {
             bufferManager.resetWithCapacity(this._capacity);
@@ -20,13 +26,13 @@ export class BufferOrchestrator {
         this._length = 0;
     }
 
-    insertBulk(items, bufferManagersMap) {
+    insertBulk(items: any[], bufferManagersMap: BufferManagersMap) {
         this.autoExtendBuffers(items.length, bufferManagersMap);
         const { offsetMap } = this;
         const offsets = [];
         for (const item of items) {
             let o = offsetMap.get(item.key);
-            const offset = o !== undefined ? o : this.nextOffset();
+            const offset = o !== undefined ? o : this.nextOffset() as number;
             offsetMap.set(item.key, offset);
             offsets.push(offset);
         }
@@ -37,7 +43,7 @@ export class BufferOrchestrator {
 
 
     // does not assign offset to the new items.
-    updateBulk(items, bufferManagersMap, bufferKeys) {
+    updateBulk(items: any[], bufferManagersMap: BufferManagersMap, bufferKeys: string[] | null = null) {
         const { offsetMap } = this;
         const offsets = [];
         for (const item of items) {
@@ -64,7 +70,7 @@ export class BufferOrchestrator {
     }
 
 
-    deleteBulk(keys, bufferManagersMap) {
+    deleteBulk(keys: string[], bufferManagersMap: BufferManagersMap) {
         const offsets = [];
         for (const key of keys) {
             const offset = this.getOffset(key);
@@ -80,13 +86,13 @@ export class BufferOrchestrator {
     }
 
 
-    getOffset(key) {
+    getOffset(key: string) {
         return this.offsetMap.get(key);
     }
 
-    nextOffset() {
+    nextOffset(): number | boolean {
         if (this.tombstoneOffsets.length > 0) {
-            const offset = this.tombstoneOffsets.pop();
+            const offset = this.tombstoneOffsets.pop() as number;
             return offset;
         }
         if (this._length < this._capacity) {
@@ -96,7 +102,7 @@ export class BufferOrchestrator {
     }
 
 
-    autoExtendBuffers(itemsLength, bufferManagersMap) {
+    autoExtendBuffers(itemsLength: number, bufferManagersMap: BufferManagersMap) {
         if (itemsLength <= this.emptySpace) return;
         const newCapacity = this.length + itemsLength;
         for (const [key, { bufferManager }] of bufferManagersMap) {
@@ -106,7 +112,7 @@ export class BufferOrchestrator {
     }
 
 
-    defrag(bufferManagers, bufferKeys) { // TODO defrag and leave some empty space
+    defrag(bufferManagers: BufferManagersMap, bufferKeys: string[]) { // TODO defrag and leave some empty space
         const offsetMap = this.offsetMap;
         const newCapacity = offsetMap.size + EXTRA_SIZE;
         if (bufferKeys) {
@@ -137,7 +143,7 @@ export class BufferOrchestrator {
     flush({ capacity = 10 } = {}) {
         this._length = 0;
         this._capacity = capacity;
-        this.tombstoneOffSet = []
+        this.tombstoneOffsets = []
         this.offsetMap.clear();
     }
 

package/util/account/single-attribute-buffer-management/{object-store.js → object-store.ts}

@@ -1,16 +1,19 @@
 
 export class ObjectStore {
+    _container;
+
+
     constructor({ initialCapcity = 10 } = {}) {
         this._container = this._createEmptyList(initialCapcity);
     }
 
 
-    resetWithCapacity(capacity) {
+    resetWithCapacity(capacity: number) {
         this._container = this._createEmptyList(capacity);
     }
 
 
-    deleteBulk(offsets) {
+    deleteBulk(offsets: number[]) {
         for (let i = 0; i < offsets.length; i++) {
             const offset = offsets[i];
             if (offset !== undefined) {
@@ -20,7 +23,7 @@ export class ObjectStore {
     }
 
 
-    insertBulk(objects, offsets) {
+    insertBulk(objects: any[], offsets: number[]) {
         for (let i = 0; i < objects.length; i++) {
             const object = objects[i];
             const offset = offsets[i];
@@ -30,7 +33,7 @@ export class ObjectStore {
         }
     }
 
-    defrag(offsetValues, occupiedCapacity, newCapacity) {
+    defrag(offsetValues: number[], occupiedCapacity: number, newCapacity: number) {
 
         const hold = this._createEmptyList(newCapacity);
         for (let i = 0; i < offsetValues.length; i++) {
@@ -42,16 +45,16 @@ export class ObjectStore {
         this._container = hold;
     }
 
-    extendBuffer(occupiedCapacity, newCapacity) {
+    extendBuffer(occupiedCapacity: number, newCapacity: number) {
         const oldCapacity = this._container.length;
         this._container = this._container.concat(this._createEmptyList(newCapacity - oldCapacity));
     }
 
-    _createEmptyList(size) {
+    _createEmptyList(size: number) {
         return new Array(size).fill(null);
     }
 
-    get(index) {
+    get(index: number) {
         return this._container[index];
     }
 

package/util/account/single-attribute-buffer-management/types.ts

@@ -0,0 +1,39 @@
+type BufferManagersMap = Map<string, {
+    bufferManager: BufferManager;
+    adaptor: (item: any) => Float32Array;
+}>;
+
+interface BufferManager {
+    gl: WebGL2RenderingContext;
+    buffer: WebGLBuffer;
+    itemSize: number;
+    bufferType: string;
+    isFreed: boolean;
+
+    insertBulk(blocks: any[], offsets: number[]): void;
+    deleteBulk(offsets: number[]): void;
+    resetWithCapacity(capacity: number): void;
+    defrag(offsetValues: MapIterator<number> | number[], occupiedCapacity: number, newCapacity: number): void;
+    extendBuffer(occupiedCapacity: number, newCapacity: number): void;
+    free(): void;
+}
+
+interface BufferOrchestrator {
+    offsetMap: Map<string, number>;
+    tombstoneOffsets: number[];
+    _length: number;
+    _capacity: number;
+    getOffset(key: string): number | undefined;
+    nextOffset(): number | boolean;
+    autoExtendBuffers(itemsLength: number, bufferManagersMap: BufferManagersMap): void;
+    updateBulk(items: any[], bufferManagersMap: BufferManagersMap, bufferKeys?: string[]): void;
+    deleteBulk(keys: string[], bufferManagersMap: BufferManagersMap): void;
+    resetWithCapacity(bufferManagersMap: BufferManagersMap, capacity: number | null): void;
+}
+
+
+export {
+    BufferManagersMap,
+    BufferManager,
+    BufferOrchestrator
+}