@genome-spy/core 0.30.0 → 0.30.2

package/src/fonts/OFL.txt

@@ -1,93 +0,0 @@
-Copyright (c) 2010-2014 by tyPoland Lukasz Dziedzic (team@latofonts.com) with Reserved Font Name "Lato"
-
-This Font Software is licensed under the SIL Open Font License, Version 1.1.
-This license is copied below, and is also available with a FAQ at:
-http://scripts.sil.org/OFL
-
-
------------------------------------------------------------
-SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
------------------------------------------------------------
-
-PREAMBLE
-The goals of the Open Font License (OFL) are to stimulate worldwide
-development of collaborative font projects, to support the font creation
-efforts of academic and linguistic communities, and to provide a free and
-open framework in which fonts may be shared and improved in partnership
-with others.
-
-The OFL allows the licensed fonts to be used, studied, modified and
-redistributed freely as long as they are not sold by themselves. The
-fonts, including any derivative works, can be bundled, embedded, 
-redistributed and/or sold with any software provided that any reserved
-names are not used by derivative works. The fonts and derivatives,
-however, cannot be released under any other type of license. The
-requirement for fonts to remain under this license does not apply
-to any document created using the fonts or their derivatives.
-
-DEFINITIONS
-"Font Software" refers to the set of files released by the Copyright
-Holder(s) under this license and clearly marked as such. This may
-include source files, build scripts and documentation.
-
-"Reserved Font Name" refers to any names specified as such after the
-copyright statement(s).
-
-"Original Version" refers to the collection of Font Software components as
-distributed by the Copyright Holder(s).
-
-"Modified Version" refers to any derivative made by adding to, deleting,
-or substituting -- in part or in whole -- any of the components of the
-Original Version, by changing formats or by porting the Font Software to a
-new environment.
-
-"Author" refers to any designer, engineer, programmer, technical
-writer or other person who contributed to the Font Software.
-
-PERMISSION & CONDITIONS
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of the Font Software, to use, study, copy, merge, embed, modify,
-redistribute, and sell modified and unmodified copies of the Font
-Software, subject to the following conditions:
-
-1) Neither the Font Software nor any of its individual components,
-in Original or Modified Versions, may be sold by itself.
-
-2) Original or Modified Versions of the Font Software may be bundled,
-redistributed and/or sold with any software, provided that each copy
-contains the above copyright notice and this license. These can be
-included either as stand-alone text files, human-readable headers or
-in the appropriate machine-readable metadata fields within text or
-binary files as long as those fields can be easily viewed by the user.
-
-3) No Modified Version of the Font Software may use the Reserved Font
-Name(s) unless explicit written permission is granted by the corresponding
-Copyright Holder. This restriction only applies to the primary font name as
-presented to the users.
-
-4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
-Software shall not be used to promote, endorse or advertise any
-Modified Version, except to acknowledge the contribution(s) of the
-Copyright Holder(s) and the Author(s) or with their explicit written
-permission.
-
-5) The Font Software, modified or unmodified, in part or in whole,
-must be distributed entirely under this license, and must not be
-distributed under any other license. The requirement for fonts to
-remain under this license does not apply to any document created
-using the Font Software.
-
-TERMINATION
-This license becomes null and void if any of the above conditions are
-not met.
-
-DISCLAIMER
-THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
-OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
-COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
-DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
-OTHER DEALINGS IN THE FONT SOFTWARE.

package/src/fonts/README.md

@@ -1,3 +0,0 @@
-# SDF fonts
-
-The json metadata and SDFs were taken from https://github.com/etiennepinchon/aframe-fonts

package/src/fonts/bmFont.d.ts

@@ -1,58 +0,0 @@
-export interface Char {
-    id: number;
-    width: number;
-    height: number;
-    xoffset: number;
-    yoffset: number;
-    xadvance: number;
-    chnl: number;
-    x: number;
-    y: number;
-    page: number;
-}
-
-export interface Info {
-    face: string;
-    size: number;
-    bold: number;
-    italic: number;
-    charset: string[];
-    unicode: number;
-    stretchH: number;
-    smooth: number;
-    aa: number;
-    padding: number[];
-    spacing: number[];
-}
-
-export interface Common {
-    lineHeight: number;
-    base: number;
-    scaleW: number;
-    scaleH: number;
-    pages: number;
-    packed: number;
-    alphaChnl: number;
-    redChnl: number;
-    greenChnl: number;
-    blueChnl: number;
-}
-
-export interface Kerning {
-    first: number;
-    second: number;
-    amount: number;
-}
-
-/**
- * BMFont as JSON.
- *
- * See: https://github.com/mattdesl/bmfont2json
- */
-export interface BMFont {
-    pages: string[];
-    chars: Char[];
-    info: Info;
-    common: Common;
-    kernings: Kerning[];
-}

package/src/fonts/bmFontManager.js

@@ -1,357 +0,0 @@
-import { InternMap } from "internmap";
-import { createTexture } from "twgl.js";
-import { isString } from "vega-util";
-import latoRegular from "../fonts/Lato-Regular.json";
-import latoRegularBitmap from "../fonts/Lato-Regular.png";
-import getMetrics from "./bmFontMetrics";
-
-const WEIGHTS = {
-    thin: 100,
-    light: 300,
-    regular: 400,
-    normal: 400,
-    medium: 500,
-    bold: 700,
-    black: 900,
-};
-
-/**
- * Loader for A-Frame fonts.
- *
- * See:
- * https://github.com/mattdesl/bmfont2json
- * https://github.com/etiennepinchon/aframe-fonts
- *
- *
- * @typedef {import("./bmFont").BMFont} BMFont
- * @typedef {import("./bmFontMetrics").BMFontMetrics} BMFontMetrics
- *
- * @typedef {"normal" | "italic"} FontStyle
- * @typedef {number} FontWeight
- *
- * @typedef {object} FontKey
- * @prop {string} family
- * @prop {FontStyle} style
- * @prop {FontWeight} weight
- *
- * @typedef {object} FontEntry
- * @prop {BMFontMetrics} metrics
- * @prop {WebGLTexture} texture
- */
-export default class BmFontManager {
-    /**
-     * @param {import("../gl/webGLHelper").default} webGLHelper
-     */
-    constructor(webGLHelper) {
-        this._webGLHelper = webGLHelper;
-
-        this.fontRepository =
-            "https://raw.githubusercontent.com/etiennepinchon/aframe-fonts/master/fonts/";
-
-        /**
-         * @type {Map<FontKey, FontEntry>}
-         */
-        this._fonts = new InternMap([], JSON.stringify);
-
-        /** @type {Map<string, Promise<GoogleFontMetadataEntry[]>>} */
-        this._metadataPromises = new Map();
-
-        /** @type {Map<string, Promise<BMFontMetrics>>} */
-        this._fontPromises = new Map();
-
-        /** @type {Promise<void>[]} Keep track of overall font loading state */
-        this._promises = [];
-
-        /**
-         * A default/fallback font to be used when font loading fails
-         * @type {FontEntry}
-         */
-        this._defaultFontEntry = {
-            metrics: getMetrics(latoRegular),
-            texture: this._createTextureNow(latoRegularBitmap),
-        };
-    }
-
-    async waitUntilReady() {
-        await Promise.all(this._promises);
-    }
-
-    /**
-     *
-     * @param {string} family For example: "Lato"
-     * @param {FontStyle} style
-     * @param {FontWeight | keyof WEIGHTS} weight
-     * @returns {FontEntry}
-     */
-    getFont(family, style = "normal", weight = "regular") {
-        if (isString(weight)) {
-            weight =
-                WEIGHTS[/** @type {keyof WEIGHTS} */ (weight.toLowerCase())];
-            if (!weight) {
-                throw new Error("Unknown font weight: " + weight);
-            }
-        }
-
-        const key = { family, style, weight };
-        let fontEntry = this._fonts.get(key);
-        if (!fontEntry) {
-            // Return and empty entry, load it asynchronously
-            fontEntry = {
-                metrics: undefined,
-                texture: undefined,
-            };
-            this._fonts.set(key, fontEntry);
-
-            this._promises.push(this._loadFontEntry(fontEntry, key));
-        }
-
-        return fontEntry;
-    }
-
-    /**
-     *
-     * @param {FontEntry} fontEntry An uninitialized font entry
-     * @param {FontKey} key
-     */
-    async _loadFontEntry(fontEntry, key) {
-        try {
-            const metadataEntries = await this._loadMetadata(key.family);
-            const filename = findFilename(metadataEntries, key);
-
-            const urlBase =
-                this.fontRepository +
-                simplifyFamily(key.family) +
-                "/" +
-                filename.replace(/\.\w+/, "");
-
-            const texturePromise = this._createTexture(urlBase + ".png");
-            const metricsPromise = this._loadFont(urlBase + ".json");
-
-            fontEntry.texture = await texturePromise;
-            fontEntry.metrics = await metricsPromise;
-        } catch (error) {
-            console.log("Cannot load font. Using default.", error);
-
-            fontEntry.metrics = this._defaultFontEntry.metrics;
-            fontEntry.texture = this._defaultFontEntry.texture;
-        }
-    }
-
-    /**
-     * @param {string} url
-     */
-    _loadFont(url) {
-        let promise = this._fontPromises.get(url);
-        if (!promise) {
-            promise = fetch(url)
-                .then((response) => {
-                    if (!response.ok) {
-                        throw new Error(
-                            "Could not load font: " + response.status
-                        );
-                    }
-                    return response;
-                })
-                .then((response) => response.json())
-                .then((json) => getMetrics(/** @type {BMFont} */ (json)));
-
-            this._fontPromises.set(url, promise);
-        }
-        return promise;
-    }
-
-    /**
-     *
-     * @param {string} family
-     */
-    _loadMetadata(family) {
-        const dir = simplifyFamily(family);
-
-        let promise = this._metadataPromises.get(dir);
-        if (!promise) {
-            promise = fetch(this.fontRepository + dir + "/METADATA.pb")
-                .then((response) => {
-                    if (!response.ok) {
-                        throw new Error(
-                            "Could not load font metadata: " + response.status
-                        );
-                    }
-                    return response;
-                })
-                .then((response) => response.text())
-                .then((text) => parseMetadataPb(text))
-                .catch((error) => {
-                    console.warn(error);
-                    return undefined;
-                });
-
-            this._metadataPromises.set(dir, promise);
-        }
-
-        return promise;
-    }
-
-    getDefaultFont() {
-        return this._defaultFontEntry;
-    }
-
-    /**
-     *
-     * @param {string} bitmapUrl
-     * @returns {Promise<WebGLTexture>}
-     */
-    _createTexture(bitmapUrl) {
-        const gl = this._webGLHelper.gl;
-
-        return new Promise((resolve, reject) => {
-            createTexture(
-                gl,
-                {
-                    src: bitmapUrl,
-                    min: gl.LINEAR,
-                },
-                (err, texture, source) => {
-                    if (err) {
-                        reject(err);
-                    } else {
-                        resolve(texture);
-                    }
-                }
-            );
-        });
-    }
-
-    /**
-     *
-     * @param {string} bitmapUrl
-     * @returns {WebGLTexture}
-     */
-    _createTextureNow(bitmapUrl) {
-        const gl = this._webGLHelper.gl;
-
-        /** @type {WebGLTexture} */
-        let texture;
-        const promise = new Promise((resolve, reject) => {
-            texture = createTexture(
-                gl,
-                {
-                    src: bitmapUrl,
-                    min: gl.LINEAR,
-                },
-                (err, texture, source) => {
-                    if (err) {
-                        reject(err);
-                    } else {
-                        resolve(texture);
-                    }
-                }
-            );
-        });
-
-        this._promises.push(promise);
-        return texture;
-    }
-}
-
-/**
- *
- * @param {string} family
- */
-function simplifyFamily(family) {
-    return family.toLowerCase().replaceAll(/[^\w]/g, "");
-}
-
-/**
- * A super-naive method for parsing METADATA.pb.
- * It's a text-format protobuf message, but I couldn't find a lightweight parser
- * for it.
- *
- * @typedef {object} GoogleFontMetadataEntry
- * @prop {string} name "Open Sans"
- * @prop {string} style "italic"
- * @prop {number} weight 400
- * @prop {string} filename "OpenSans-Italic.ttf"
- * @prop {string} post_script_name "OpenSans-Italic"
- * @prop {string} full_name "Open Sans Italic"
- * @prop {string} copyright "Digitized data copyright  2010-2011, Google Corporation."
- *
- * @param {string} metadata
- * @returns {GoogleFontMetadataEntry[]}
- */
-function parseMetadataPb(metadata) {
-    const lines = metadata.split("\n");
-
-    /** @type {GoogleFontMetadataEntry[]} */
-    const entries = [];
-
-    /** @type {GoogleFontMetadataEntry} */
-    let entry;
-
-    for (const line of lines) {
-        if (line.startsWith("fonts {")) {
-            /** @type {GoogleFontMetadataEntry} */
-            entry = {
-                name: undefined,
-                style: undefined,
-                weight: undefined,
-                filename: undefined,
-                post_script_name: undefined,
-                full_name: undefined,
-                copyright: undefined,
-            };
-        }
-
-        if (line.startsWith("}")) {
-            entries.push(entry);
-            entry = undefined;
-        }
-
-        if (entry) {
-            let m = line.match(/^\s*([A-Za-z_]+):[ ]?"(.*)"$/);
-            if (m) {
-                const key = /** @type {keyof GoogleFontMetadataEntry}*/ (m[1]);
-                // @ts-ignore
-                entry[key] = m[2];
-            }
-
-            m = line.match(/^\s*([A-Za-z_]+):[ ]?(\d+)$/);
-            if (m) {
-                const key = /** @type {keyof GoogleFontMetadataEntry}*/ (m[1]);
-                // @ts-ignore
-                entry[key] = +m[2];
-            }
-        }
-    }
-
-    return entries;
-}
-
-/**
- * @param {GoogleFontMetadataEntry[]} metadataEntries
- * @param {FontKey} key
- */
-function findFilename(metadataEntries, key) {
-    /** @type {GoogleFontMetadataEntry}  */
-    let closest;
-    let closestDistance = Number.POSITIVE_INFINITY;
-
-    for (const e of metadataEntries) {
-        if (
-            key.family.localeCompare(e.name, undefined, {
-                sensitivity: "accent",
-            }) != 0
-        ) {
-            continue;
-        }
-
-        if (key.style == e.style) {
-            const distance = Math.abs(key.weight - e.weight);
-            if (distance < closestDistance) {
-                closestDistance = distance;
-                closest = e;
-            }
-        }
-    }
-
-    return closest?.filename;
-}

package/src/fonts/bmFontMetrics.js

@@ -1,108 +0,0 @@
-export const SDF_PADDING = 5; // Not sure if this is same with all msdf bmfonts...
-
-const MAX_ASCII = 127;
-
-/**
- * Metrics calculation for msdf bmfonts:
- *
- * https://github.com/mattdesl/bmfont2json
- * https://github.com/etiennepinchon/aframe-fonts
- *
- * @typedef {import("./bmFont").Char} Char
- *
- * @typedef {object} BMFontMetrics
- * @prop {(text: string, fontSize?: number) => number} measureWidth
- * @prop {(charCode: number) => Char} getCharByCode
- * @prop {(char: string) => Char} getChar
- * @prop {number} xHeight
- * @prop {number} capHeight
- * @prop {number} descent
- * @prop {import("./bmFont").Common} common
- *
- * @param {import("./bmFont").BMFont} bmFont
- * @returns {BMFontMetrics}
- */
-export default function getMetrics(bmFont) {
-    /**
-     * Use an ordinary array for fast lookup of ascii chars
-     *
-     * @type {import("./bmFont").Char[]}
-     */
-    const asciiChars = [];
-
-    // Ensure that the array is not "holey": https://v8.dev/blog/elements-kinds
-    for (let i = 0; i <= MAX_ASCII; i++) {
-        asciiChars.push(undefined);
-    }
-
-    /**
-     * Put the rest (unicode = sparse and infrequent) chars into a map
-     *
-     * @type {Map<number, Char>}
-     */
-    const unicodeChars = new Map();
-
-    for (const char of bmFont.chars) {
-        if (char.id <= MAX_ASCII) {
-            asciiChars[char.id] = char;
-        } else {
-            unicodeChars.set(char.id, char);
-        }
-    }
-
-    // Workaround https://github.com/d3/d3-format/commit/39f41940386024d3b8a2172240189a0950c8dd23
-    const minusHyphen = 8722;
-    if (!unicodeChars.has(minusHyphen)) {
-        unicodeChars.set(minusHyphen, asciiChars["-".charCodeAt(0)]);
-    }
-
-    /** @param {number} charCode */
-    function getCharByCode(charCode) {
-        const char =
-            charCode <= MAX_ASCII
-                ? asciiChars[charCode]
-                : unicodeChars.get(charCode);
-        return char || asciiChars[63];
-    }
-
-    /** @param {string} char */
-    function getChar(char) {
-        return getCharByCode(char.charCodeAt(0));
-    }
-
-    const base = bmFont.common.base;
-
-    // Font metrics are not available in the bmfont metadata. Have to calculate...
-    const x = getChar("x");
-    const X = getChar("X");
-    const q = getChar("q");
-
-    const xHeight = x.height - SDF_PADDING * 2;
-    const capHeight = X.height - SDF_PADDING * 2;
-    const descent = q.height - x.height + q.yoffset - x.yoffset;
-
-    /**
-     * TODO: Kerning
-     *
-     * @param {string} text text to measure
-     * @param {number} fontSize
-     */
-    function measureWidth(text, fontSize = 1.0) {
-        let width = 0;
-        for (let i = 0; i < text.length; i++) {
-            width += getCharByCode(text.charCodeAt(i)).xadvance;
-        }
-
-        return (width / base) * fontSize;
-    }
-
-    return {
-        measureWidth,
-        getCharByCode,
-        getChar,
-        xHeight,
-        capHeight,
-        descent,
-        common: bmFont.common,
-    };
-}