@scoova/mgl 1.0.0

package/src/util/primitives.test.ts

@@ -0,0 +1,140 @@
+import {Aabb, Frustum} from './primitives';
+import {mat4, vec3, vec4} from 'gl-matrix';
+
+describe('primitives', () => {
+    test('Create an aabb', () => {
+        const min = vec3.fromValues(0, 0, 0);
+        const max = vec3.fromValues(2, 4, 6);
+        const aabb = new Aabb(min, max);
+
+        expect(aabb.min).toBe(min);
+        expect(aabb.max).toBe(max);
+        expect(aabb.center).toEqual([1, 2, 3]);
+    });
+
+    test('Create 4 quadrants', () => {
+        const min = vec3.fromValues(0, 0, 0);
+        const max = vec3.fromValues(2, 4, 1);
+        const aabb = new Aabb(min, max);
+
+        expect(aabb.quadrant(0)).toEqual(new Aabb(vec3.fromValues(0, 0, 0), vec3.fromValues(1, 2, 1)));
+        expect(aabb.quadrant(1)).toEqual(new Aabb(vec3.fromValues(1, 0, 0), vec3.fromValues(2, 2, 1)));
+        expect(aabb.quadrant(2)).toEqual(new Aabb(vec3.fromValues(0, 2, 0), vec3.fromValues(1, 4, 1)));
+        expect(aabb.quadrant(3)).toEqual(new Aabb(vec3.fromValues(1, 2, 0), vec3.fromValues(2, 4, 1)));
+
+    });
+
+    test('Distance to a point', () => {
+        const min = vec3.fromValues(-1, -1, -1);
+        const max = vec3.fromValues(1, 1, 1);
+        const aabb = new Aabb(min, max);
+
+        expect(aabb.distanceX([0.5, -0.5])).toBe(0);
+        expect(aabb.distanceY([0.5, -0.5])).toBe(0);
+
+        expect(aabb.distanceX([1, 1])).toBe(0);
+        expect(aabb.distanceY([1, 1])).toBe(0);
+
+        expect(aabb.distanceX([0, 10])).toBe(0);
+        expect(aabb.distanceY([0, 10])).toBe(-9);
+
+        expect(aabb.distanceX([-2, -2])).toBe(1);
+        expect(aabb.distanceY([-2, -2])).toBe(1);
+    });
+
+    const createTestCameraFrustum = (fovy, aspectRatio, zNear, zFar, elevation, rotation) => {
+        const proj = new Float64Array(16) as any as mat4;
+        const invProj = new Float64Array(16) as any as mat4;
+
+        // Note that left handed coordinate space is used where z goes towards the sky.
+        // Y has to be flipped as well because it's part of the projection/camera matrix used in transform.js
+        mat4.perspective(proj, fovy, aspectRatio, zNear, zFar);
+        mat4.scale(proj, proj, [1, -1, 1]);
+        mat4.translate(proj, proj, [0, 0, elevation]);
+        mat4.rotateZ(proj, proj, rotation);
+        mat4.invert(invProj, proj);
+
+        return Frustum.fromInvProjectionMatrix(invProj, 1.0, 0.0);
+    };
+
+    test('Aabb fully inside a frustum', () => {
+        const frustum = createTestCameraFrustum(Math.PI / 2, 1.0, 0.1, 100.0, -5, 0);
+
+        // Intersection test is done in xy-plane
+        const aabbList = [
+            new Aabb(vec3.fromValues(-1, -1, 0), vec3.fromValues(1, 1, 0)),
+            new Aabb(vec3.fromValues(-5, -5, 0), vec3.fromValues(5, 5, 0)),
+            new Aabb(vec3.fromValues(-5, -5, 0), vec3.fromValues(-4, -2, 0))
+        ];
+
+        for (const aabb of aabbList)
+            expect(aabb.intersects(frustum)).toBe(2);
+
+    });
+
+    test('Aabb intersecting with a frustum', () => {
+        const frustum = createTestCameraFrustum(Math.PI / 2, 1.0, 0.1, 100.0, -5, 0);
+
+        const aabbList = [
+            new Aabb(vec3.fromValues(-6, -6, 0), vec3.fromValues(6, 6, 0)),
+            new Aabb(vec3.fromValues(-6, -6, 0), vec3.fromValues(-5, -5, 0))
+        ];
+
+        for (const aabb of aabbList)
+            expect(aabb.intersects(frustum)).toBe(1);
+
+    });
+
+    test('No intersection between aabb and frustum', () => {
+        const frustum = createTestCameraFrustum(Math.PI / 2, 1.0, 0.1, 100.0, -5, 0);
+
+        const aabbList = [
+            new Aabb(vec3.fromValues(-6, 0, 0), vec3.fromValues(-5.5, 0, 0)),
+            new Aabb(vec3.fromValues(-6, -6, 0), vec3.fromValues(-5.5, -5.5, 0)),
+            new Aabb(vec3.fromValues(7, -10, 0), vec3.fromValues(7.1, 20, 0))
+        ];
+
+        for (const aabb of aabbList)
+            expect(aabb.intersects(frustum)).toBe(0);
+
+    });
+
+});
+
+describe('frustum', () => {
+    test('Create a frustum from inverse projection matrix', () => {
+        const proj = new Float64Array(16) as any as mat4;
+        const invProj = new Float64Array(16) as any as mat4;
+        mat4.perspective(proj, Math.PI / 2, 1.0, 0.1, 100.0);
+        mat4.invert(invProj, proj);
+
+        const frustum = Frustum.fromInvProjectionMatrix(invProj, 1.0, 0.0);
+        // mat4.perspective generates a projection matrix for right handed coordinate space.
+        // This means that forward direction will be -z
+        const expectedFrustumPoints = [
+            [-0.1, 0.1, -0.1, 1.0],
+            [0.1, 0.1, -0.1, 1.0],
+            [0.1, -0.1, -0.1, 1.0],
+            [-0.1, -0.1, -0.1, 1.0],
+            [-100.0, 100.0, -100.0, 1.0],
+            [100.0, 100.0, -100.0, 1.0],
+            [100.0, -100.0, -100.0, 1.0],
+            [-100.0, -100.0, -100.0, 1.0],
+        ];
+
+        frustum.points = frustum.points.map(array => array.map(n => Math.round(n * 10) / 10)) as vec4[];
+        frustum.planes = frustum.planes.map(array => array.map(n => Math.round(n * 1000) / 1000)) as vec4[];
+
+        const expectedFrustumPlanes = [
+            [0, 0, 1.0, 0.1],
+            [-0, -0, -1.0, -100.0],
+            [-0.707, 0, 0.707, -0],
+            [0.707, 0, 0.707, -0],
+            [0, -0.707, 0.707, -0],
+            [-0, 0.707, 0.707, -0]
+        ];
+
+        expect(frustum.points).toEqual(expectedFrustumPoints);
+        expect(frustum.planes).toEqual(expectedFrustumPlanes);
+    });
+});

package/src/util/primitives.ts

@@ -0,0 +1,143 @@
+import {mat4, vec3, vec4} from 'gl-matrix';
+
+class Frustum {
+
+    constructor(public points: vec4[], public planes: vec4[]) { }
+
+    public static fromInvProjectionMatrix(invProj: mat4, worldSize: number, zoom: number): Frustum {
+        const clipSpaceCorners = [
+            [-1, 1, -1, 1],
+            [1, 1, -1, 1],
+            [1, -1, -1, 1],
+            [-1, -1, -1, 1],
+            [-1, 1, 1, 1],
+            [1, 1, 1, 1],
+            [1, -1, 1, 1],
+            [-1, -1, 1, 1]
+        ];
+
+        const scale = Math.pow(2, zoom);
+
+        // Transform frustum corner points from clip space to tile space, Z to meters
+        const frustumCoords = clipSpaceCorners.map(v => {
+            v = vec4.transformMat4([] as any, v as any, invProj) as any;
+            const s = 1.0 / v[3] / worldSize * scale;
+            return vec4.mul(v as any, v as any, [s, s, 1.0 / v[3], s] as vec4);
+        });
+
+        const frustumPlanePointIndices = [
+            [0, 1, 2],  // near
+            [6, 5, 4],  // far
+            [0, 3, 7],  // left
+            [2, 1, 5],  // right
+            [3, 2, 6],  // bottom
+            [0, 4, 5]   // top
+        ];
+
+        const frustumPlanes = frustumPlanePointIndices.map((p: number[]) => {
+            const a = vec3.sub([] as any, frustumCoords[p[0]] as vec3, frustumCoords[p[1]] as vec3);
+            const b = vec3.sub([] as any, frustumCoords[p[2]] as vec3, frustumCoords[p[1]] as vec3);
+            const n = vec3.normalize([] as any, vec3.cross([] as any, a, b)) as any;
+            const d = -vec3.dot(n, frustumCoords[p[1]] as vec3);
+            return n.concat(d);
+        });
+
+        return new Frustum(frustumCoords, frustumPlanes);
+    }
+}
+
+class Aabb {
+    min: vec3;
+    max: vec3;
+    center: vec3;
+
+    constructor(min_: vec3, max_: vec3) {
+        this.min = min_;
+        this.max = max_;
+        this.center = vec3.scale([] as any, vec3.add([] as any, this.min, this.max), 0.5);
+    }
+
+    quadrant(index: number): Aabb {
+        const split = [(index % 2) === 0, index < 2];
+        const qMin = vec3.clone(this.min);
+        const qMax = vec3.clone(this.max);
+        for (let axis = 0; axis < split.length; axis++) {
+            qMin[axis] = split[axis] ? this.min[axis] : this.center[axis];
+            qMax[axis] = split[axis] ? this.center[axis] : this.max[axis];
+        }
+        // Elevation is always constant, hence quadrant.max.z = this.max.z
+        qMax[2] = this.max[2];
+        return new Aabb(qMin, qMax);
+    }
+
+    distanceX(point: Array<number>): number {
+        const pointOnAabb = Math.max(Math.min(this.max[0], point[0]), this.min[0]);
+        return pointOnAabb - point[0];
+    }
+
+    distanceY(point: Array<number>): number {
+        const pointOnAabb = Math.max(Math.min(this.max[1], point[1]), this.min[1]);
+        return pointOnAabb - point[1];
+    }
+
+    // Performs a frustum-aabb intersection test. Returns 0 if there's no intersection,
+    // 1 if shapes are intersecting and 2 if the aabb if fully inside the frustum.
+    intersects(frustum: Frustum): number {
+        // Execute separating axis test between two convex objects to find intersections
+        // Each frustum plane together with 3 major axes define the separating axes
+
+        const aabbPoints = [
+            [this.min[0], this.min[1], this.min[2], 1],
+            [this.max[0], this.min[1], this.min[2], 1],
+            [this.max[0], this.max[1], this.min[2], 1],
+            [this.min[0], this.max[1], this.min[2], 1],
+            [this.min[0], this.min[1], this.max[2], 1],
+            [this.max[0], this.min[1], this.max[2], 1],
+            [this.max[0], this.max[1], this.max[2], 1],
+            [this.min[0], this.max[1], this.max[2], 1]
+        ];
+
+        let fullyInside = true;
+
+        for (let p = 0; p < frustum.planes.length; p++) {
+            const plane = frustum.planes[p];
+            let pointsInside = 0;
+
+            for (let i = 0; i < aabbPoints.length; i++) {
+                if (vec4.dot(plane, aabbPoints[i] as any) >= 0) {
+                    pointsInside++;
+                }
+            }
+
+            if (pointsInside === 0)
+                return 0;
+
+            if (pointsInside !== aabbPoints.length)
+                fullyInside = false;
+        }
+
+        if (fullyInside)
+            return 2;
+
+        for (let axis = 0; axis < 3; axis++) {
+            let projMin = Number.MAX_VALUE;
+            let projMax = -Number.MAX_VALUE;
+
+            for (let p = 0; p < frustum.points.length; p++) {
+                const projectedPoint = frustum.points[p][axis] - this.min[axis];
+
+                projMin = Math.min(projMin, projectedPoint);
+                projMax = Math.max(projMax, projectedPoint);
+            }
+
+            if (projMax < 0 || projMin > this.max[axis] - this.min[axis])
+                return 0;
+        }
+
+        return 1;
+    }
+}
+export {
+    Aabb,
+    Frustum
+};

package/src/util/request_manager.ts

@@ -0,0 +1,42 @@
+import type {RequestParameters} from './ajax';
+
+/**
+ * A type of MapLibre resource.
+ */
+export const enum ResourceType {
+    Glyphs = 'Glyphs',
+    Image = 'Image',
+    Source = 'Source',
+    SpriteImage = 'SpriteImage',
+    SpriteJSON = 'SpriteJSON',
+    Style = 'Style',
+    Tile = 'Tile',
+    Unknown = 'Unknown',
+}
+
+/**
+ * This function is used to tranform a request.
+ * It is used just before executing the relevant request.
+ */
+export type RequestTransformFunction = (url: string, resourceType?: ResourceType) => RequestParameters | undefined;
+
+export class RequestManager {
+    _transformRequestFn: RequestTransformFunction;
+
+    constructor(transformRequestFn?: RequestTransformFunction) {
+        this._transformRequestFn = transformRequestFn;
+    }
+
+    transformRequest(url: string, type: ResourceType) {
+        if (this._transformRequestFn) {
+            return this._transformRequestFn(url, type) || {url};
+        }
+
+        return {url};
+    }
+
+    setTransformRequest(transformRequest: RequestTransformFunction) {
+        this._transformRequestFn = transformRequest;
+    }
+}
+

package/src/util/resolve_tokens.test.ts

@@ -0,0 +1,45 @@
+import {resolveTokens} from './resolve_tokens';
+
+test('resolveToken', () => {
+    expect('3 Fine Fields').toBe(resolveTokens({a: 3, b: 'Fine', c: 'Fields'}, '{a} {b} {c}'));
+
+    // No tokens.
+    expect(resolveTokens({}, 'Test')).toBe('Test');
+
+    // Basic.
+    expect(resolveTokens({name: 'Test'}, '{name}')).toBe('Test');
+    expect(resolveTokens({name: 'Test'}, '{name}-suffix')).toBe('Test-suffix');
+
+    // No properties.
+    expect(resolveTokens(null, '{name}')).toBe('');
+    expect(resolveTokens(null, '{name}-suffix')).toBe('-suffix');
+
+    // Undefined property.
+    expect(resolveTokens({}, '{name}')).toBe('');
+    expect(resolveTokens({}, '{name}-suffix')).toBe('-suffix');
+
+    // Non-latin.
+    expect(resolveTokens({city: '서울특별시'}, '{city}')).toBe('서울특별시');
+
+    // Unicode up to 65535.
+    expect(resolveTokens({text: '\ufff0'}, '{text}')).toBe('\ufff0');
+    expect(resolveTokens({text: '\uffff'}, '{text}')).toBe('\uffff');
+
+    // Non-string values cast to strings.
+    expect(resolveTokens({name: 5000}, '{name}')).toBe('5000');
+    expect(resolveTokens({name: -15.5}, '{name}')).toBe('-15.5');
+    expect(resolveTokens({name: true}, '{name}')).toBe('true');
+
+    // Non-string values cast to strings, with token replacement.
+    expect(resolveTokens({name: 5000}, '{name}-suffix')).toBe('5000-suffix');
+    expect(resolveTokens({name: -15.5}, '{name}-suffix')).toBe('-15.5-suffix');
+    expect(resolveTokens({name: true}, '{name}-suffix')).toBe('true-suffix');
+
+    // Special characters in token.
+    expect(resolveTokens({'dashed-property': 'dashed'}, '{dashed-property}')).toBe('dashed');
+    expect(resolveTokens({'HØYDE': 150}, '{HØYDE} m')).toBe('150 m');
+    expect(
+        resolveTokens({'$special:characters;': 'mapbox'}, '{$special:characters;}')
+    ).toBe('mapbox');
+
+});

package/src/util/resolve_tokens.ts

@@ -0,0 +1,17 @@
+/**
+ * Replace tokens in a string template with values in an object
+ *
+ * @param properties - a key/value relationship between tokens and replacements
+ * @param text - the template string
+ * @returns the template with tokens replaced
+ */
+export function resolveTokens(
+    properties: {
+        readonly [x: string]: unknown;
+    } | null,
+    text: string
+): string {
+    return text.replace(/{([^{}]+)}/g, (match, key: string) => {
+        return properties && key in properties ? String(properties[key]) : '';
+    });
+}

package/src/util/script_detection.test.ts

@@ -0,0 +1,138 @@
+import {charAllowsIdeographicBreaking, charAllowsLetterSpacing, charHasUprightVerticalOrientation, charInComplexShapingScript, charInRTLScript} from './script_detection';
+
+describe('charAllowsIdeographicBreaking', () => {
+    test('disallows ideographic breaking of Latin text', () => {
+        expect(charAllowsIdeographicBreaking('A'.codePointAt(0))).toBe(false);
+    });
+
+    test('allows ideographic breaking of ideographic punctuation', () => {
+        expect(charAllowsIdeographicBreaking('〈'.codePointAt(0))).toBe(true);
+    });
+
+    test('allows ideographic breaking of Bopomofo text', () => {
+        expect(charAllowsIdeographicBreaking('ㄎ'.codePointAt(0))).toBe(true);
+    });
+
+    test('allows ideographic breaking of Chinese and Vietnamese text', () => {
+        expect(charAllowsIdeographicBreaking('市'.codePointAt(0))).toBe(true);
+        expect(charAllowsIdeographicBreaking('𡔖'.codePointAt(0))).toBe(true);
+    });
+
+    test('disallows ideographic breaking of Korean text', () => {
+        expect(charAllowsIdeographicBreaking('아'.codePointAt(0))).toBe(false);
+    });
+
+    test('allows ideographic breaking of Japanese text', () => {
+        expect(charAllowsIdeographicBreaking('あ'.codePointAt(0))).toBe(true);
+        expect(charAllowsIdeographicBreaking('カ'.codePointAt(0))).toBe(true);
+    });
+
+    test('allows ideographic breaking of Yi text', () => {
+        expect(charAllowsIdeographicBreaking('ꉆ'.codePointAt(0))).toBe(true);
+    });
+});
+
+describe('charAllowsLetterSpacing', () => {
+    test('allows letter spacing of Latin text', () => {
+        expect(charAllowsLetterSpacing('A'.codePointAt(0))).toBe(true);
+    });
+
+    test('disallows ideographic breaking of Arabic text', () => {
+        // Arabic
+        expect(charAllowsLetterSpacing('۳'.codePointAt(0))).toBe(false);
+        // Arabic Supplement
+        expect(charAllowsLetterSpacing('ݣ'.codePointAt(0))).toBe(false);
+        // Arabic Extended-A
+        expect(charAllowsLetterSpacing('ࢳ'.codePointAt(0))).toBe(false);
+        // Arabic Extended-B
+        expect(charAllowsLetterSpacing('࢐'.codePointAt(0))).toBe(false);
+        // Arabic Presentation Forms-A
+        expect(charAllowsLetterSpacing('ﰤ'.codePointAt(0))).toBe(false);
+        // Arabic Presentation Forms-B
+        expect(charAllowsLetterSpacing('ﺽ'.codePointAt(0))).toBe(false);
+    });
+});
+
+describe('charHasUprightVerticalOrientation', () => {
+    test('rotates Latin text sideways', () => {
+        expect(charHasUprightVerticalOrientation('A'.codePointAt(0))).toBe(false);
+    });
+
+    test('keeps Bopomofo text upright', () => {
+        expect(charHasUprightVerticalOrientation('ㄎ'.codePointAt(0))).toBe(true);
+    });
+
+    test('keeps Canadian Aboriginal text upright', () => {
+        expect(charHasUprightVerticalOrientation('ᐃ'.codePointAt(0))).toBe(true);
+    });
+
+    test('keeps Chinese and Vietnamese text upright', () => {
+        expect(charHasUprightVerticalOrientation('市'.codePointAt(0))).toBe(true);
+        expect(charHasUprightVerticalOrientation('𡔖'.codePointAt(0))).toBe(true);
+    });
+
+    test('keeps Korean text upright', () => {
+        expect(charHasUprightVerticalOrientation('아'.codePointAt(0))).toBe(true);
+    });
+
+    test('keeps Japanese text upright', () => {
+        expect(charHasUprightVerticalOrientation('あ'.codePointAt(0))).toBe(true);
+        expect(charHasUprightVerticalOrientation('カ'.codePointAt(0))).toBe(true);
+    });
+
+    test('keeps Yi text upright', () => {
+        expect(charHasUprightVerticalOrientation('ꉆ'.codePointAt(0))).toBe(true);
+    });
+});
+
+describe('charInComplexShapingScript', () => {
+    test('recognizes that Arabic text needs complex shaping', () => {
+        // Non-Arabic
+        expect(charInComplexShapingScript('3'.codePointAt(0))).toBe(false);
+        // Arabic
+        expect(charInComplexShapingScript('۳'.codePointAt(0))).toBe(true);
+        // Arabic Supplement
+        expect(charInComplexShapingScript('ݣ'.codePointAt(0))).toBe(true);
+        // Arabic Extended-A
+        expect(charInComplexShapingScript('ࢳ'.codePointAt(0))).toBe(true);
+        // Arabic Extended-B
+        expect(charInComplexShapingScript('࢐'.codePointAt(0))).toBe(true);
+        // Arabic Presentation Forms-A
+        expect(charInComplexShapingScript('ﰤ'.codePointAt(0))).toBe(true);
+        // Arabic Presentation Forms-B
+        expect(charInComplexShapingScript('ﺽ'.codePointAt(0))).toBe(true);
+    });
+});
+
+describe('charInRTLScript', () => {
+    test('does not identify direction-neutral text as right-to-left', () => {
+        expect(charInRTLScript('3'.codePointAt(0))).toBe(false);
+    });
+
+    test('identifies Arabic text as right-to-left', () => {
+        // Arabic
+        expect(charInRTLScript('۳'.codePointAt(0))).toBe(true);
+        // Arabic Supplement
+        expect(charInRTLScript('ݣ'.codePointAt(0))).toBe(true);
+        // Arabic Extended-A
+        expect(charInRTLScript('ࢳ'.codePointAt(0))).toBe(true);
+        // Arabic Extended-B
+        expect(charInRTLScript('࢐'.codePointAt(0))).toBe(true);
+        // Arabic Presentation Forms-A
+        expect(charInRTLScript('ﰤ'.codePointAt(0))).toBe(true);
+        // Arabic Presentation Forms-B
+        expect(charInRTLScript('ﺽ'.codePointAt(0))).toBe(true);
+    });
+
+    test('identifies Hebrew text as right-to-left', () => {
+        // Hebrew
+        expect(charInRTLScript('ה'.codePointAt(0))).toBe(true);
+        // Alphabetic Presentation Forms
+        expect(charInRTLScript('ﬡ'.codePointAt(0))).toBe(true);
+    });
+
+    test('identifies Thaana text as right-to-left', () => {
+        // Thaana
+        expect(charInRTLScript('ޘ'.codePointAt(0))).toBe(true);
+    });
+});