@glissandoo/lib 1.56.0 → 1.57.0

package/helpers/firestore.d.ts

@@ -0,0 +1,11 @@
+import * as firestore from '../types/firestore';
+/** Create a DocumentSnapshot. */
+export declare function makeDocumentSnapshot(
+/** Key-value pairs representing data in the document, pass in `{}` to mock the snapshot of
+ * a document that doesn't exist.
+ */
+data: {
+    [key: string]: unknown;
+}, 
+/** Full path of the reference (e.g. 'users/alovelace') */
+refPath: string, project: string): firestore.DocumentSnapshot<firestore.DocumentData>;

package/helpers/firestore.js

@@ -0,0 +1,196 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDocumentSnapshot = void 0;
+const lodash_1 = require("lodash");
+const firestore = __importStar(require("../types/firestore"));
+const firebase = __importStar(require("firebase-admin"));
+/** @internal */
+function testApp() {
+    if (typeof testApp.singleton === 'undefined') {
+        testApp.init();
+    }
+    return testApp.singleton;
+}
+/** @internal */
+(function (testApp) {
+    testApp.init = () => (testApp.singleton = new testApp.App());
+    class App {
+        constructor() {
+            return;
+        }
+        getApp() {
+            if (typeof this.appSingleton === 'undefined') {
+                const config = process.env.FIREBASE_CONFIG
+                    ? JSON.parse(process.env.FIREBASE_CONFIG)
+                    : {};
+                this.appSingleton = firebase.initializeApp(config, 
+                // Give this app a name so it does not conflict with apps that user initialized.
+                'firebase-functions-test');
+            }
+            return this.appSingleton;
+        }
+        deleteApp() {
+            if (this.appSingleton) {
+                void this.appSingleton.delete();
+                delete this.appSingleton;
+            }
+        }
+    }
+    testApp.App = App;
+})(testApp || (testApp = {}));
+/** @internal */
+function objectToValueProto(data) {
+    const encodeHelper = (val) => {
+        if (typeof val === 'string') {
+            return {
+                stringValue: val,
+            };
+        }
+        if (typeof val === 'boolean') {
+            return {
+                booleanValue: val,
+            };
+        }
+        if (typeof val === 'number') {
+            if (val % 1 === 0) {
+                return {
+                    integerValue: val,
+                };
+            }
+            return {
+                doubleValue: val,
+            };
+        }
+        if (val instanceof Date) {
+            return {
+                timestampValue: val.toISOString(),
+            };
+        }
+        if (val instanceof Array) {
+            const encodedElements = [];
+            for (const elem of val) {
+                const enc = encodeHelper(elem);
+                if (enc) {
+                    encodedElements.push(enc);
+                }
+            }
+            return {
+                arrayValue: {
+                    values: encodedElements,
+                },
+            };
+        }
+        if (val === null) {
+            // TODO: Look this up. This is a google.protobuf.NulLValue,
+            // and everything in google.protobuf has a customized JSON encoder.
+            // OTOH, Firestore's generated .d.ts files don't take this into
+            // account and have the default proto layout.
+            return {
+                nullValue: 'NULL_VALUE',
+            };
+        }
+        if (val instanceof Buffer || val instanceof Uint8Array) {
+            return {
+                bytesValue: val,
+            };
+        }
+        if (val instanceof firestore.DocumentReference) {
+            const projectId = (0, lodash_1.get)(val, '_referencePath.projectId');
+            const database = (0, lodash_1.get)(val, '_referencePath.databaseId');
+            const referenceValue = [
+                'projects',
+                projectId,
+                'databases',
+                database,
+                val.path,
+            ].join('/');
+            return { referenceValue };
+        }
+        if (val instanceof firestore.Timestamp) {
+            return {
+                timestampValue: val.toDate().toISOString(),
+            };
+        }
+        if (val instanceof firestore.GeoPoint) {
+            return {
+                geoPointValue: {
+                    latitude: val.latitude,
+                    longitude: val.longitude,
+                },
+            };
+        }
+        if ((0, lodash_1.isPlainObject)(val)) {
+            if (!val)
+                return;
+            return {
+                mapValue: {
+                    fields: objectToValueProto(val),
+                },
+            };
+        }
+        throw new Error('Cannot encode to a Firestore Value');
+    };
+    return (0, lodash_1.mapValues)(data, encodeHelper);
+}
+function dateToTimestampProto(timeString) {
+    if (typeof timeString === 'undefined') {
+        return;
+    }
+    const date = new Date(timeString);
+    const seconds = Math.floor(date.getTime() / 1000);
+    let nanos = 0;
+    if (timeString.length > 20) {
+        const nanoString = timeString.substring(20, timeString.length - 1);
+        const trailingZeroes = 9 - nanoString.length;
+        nanos = parseInt(nanoString, 10) * Math.pow(10, trailingZeroes);
+    }
+    return { seconds, nanos };
+}
+/** Create a DocumentSnapshot. */
+function makeDocumentSnapshot(
+/** Key-value pairs representing data in the document, pass in `{}` to mock the snapshot of
+ * a document that doesn't exist.
+ */
+data, 
+/** Full path of the reference (e.g. 'users/alovelace') */
+refPath, project) {
+    const firestoreService = firebase.firestore(testApp().getApp());
+    const resource = `projects/${project}/databases/(default)/documents/${refPath}`;
+    const proto = (0, lodash_1.isEmpty)(data)
+        ? resource
+        : {
+            fields: objectToValueProto(data),
+            createTime: dateToTimestampProto(new Date().toISOString()),
+            updateTime: dateToTimestampProto(new Date().toISOString()),
+            name: resource,
+        };
+    const readTimeProto = dateToTimestampProto(new Date().toISOString());
+    /* eslint-disable */
+    // @ts-ignore
+    return firestoreService.snapshot_(proto, readTimeProto, 'json');
+    /* eslint-enable */
+}
+exports.makeDocumentSnapshot = makeDocumentSnapshot;

package/lang/ca.json

@@ -130,6 +130,7 @@
     "instruments.ukelele": "Ukelele",
     "instruments.viola": "Viola",
     "instruments.violin": "Violí",
+    "instruments.unknown": "Instrument desconegut",
     "musicStyles.banda-cornetas-y-tambores": "Banda de cornetes i tambors",
     "musicStyles.banda-de-musica": "Banda de música",
     "musicStyles.batucada": "Batucada",

package/lang/de.json

@@ -130,6 +130,7 @@
     "instruments.ukelele": "Ukulele",
     "instruments.viola": "Viola",
     "instruments.violin": "Violine",
+    "instruments.unknown": "Unbekanntes Instrument",
     "musicStyles.banda-cornetas-y-tambores": "Schlagzeug und Blasorchester",
     "musicStyles.banda-de-musica": "Blasorchester",
     "musicStyles.batucada": "Batukada",

package/lang/en.json

@@ -130,6 +130,7 @@
     "instruments.ukelele": "Ukelele",
     "instruments.viola": "Viola",
     "instruments.violin": "Violin",
+    "instruments.unknown": "Unknown {musicType}",
     "musicStyles.banda-cornetas-y-tambores": "Drums and winds band",
     "musicStyles.banda-de-musica": "Concert band",
     "musicStyles.batucada": "Batucada",

package/lang/es.json

@@ -130,6 +130,7 @@
     "instruments.ukelele": "Ukelele",
     "instruments.viola": "Viola",
     "instruments.violin": "Violín",
+    "instruments.unknown": "Instrumento desconocido",
     "musicStyles.banda-cornetas-y-tambores": "Banda de cornetas y tambores",
     "musicStyles.banda-de-musica": "Banda de música",
     "musicStyles.batucada": "Batucada",

package/lang/eu.json

@@ -129,7 +129,8 @@
     "instruments.txistu": "Txistua",
     "instruments.ukelele": "Ukelelea",
     "instruments.viola": "Biola",
-    "instruments.violin": "Biolina\n",
+    "instruments.violin": "Biolina",
+    "instruments.unknown": "Intrumentu ezezaguna",
     "musicStyles.banda-cornetas-y-tambores": "Danbor eta korneta banda",
     "musicStyles.banda-de-musica": "Musika banda",
     "musicStyles.batucada": "Batukada",

package/lang/gl.json

@@ -130,6 +130,7 @@
     "instruments.ukelele": "Ukelele",
     "instruments.viola": "Viola",
     "instruments.violin": "Violín",
+    "instruments.unknown": "Instrumento descoñecido",
     "musicStyles.banda-cornetas-y-tambores": "Banda de cornetas e tambores",
     "musicStyles.banda-de-musica": "Banda de música",
     "musicStyles.batucada": "Batucada",

package/lang/pt.json

@@ -130,6 +130,7 @@
     "instruments.ukelele": "Ukelele",
     "instruments.viola": "viola",
     "instruments.violin": "Violino",
+    "instruments.unknown": "Instrumento desconhecido",
     "musicStyles.banda-cornetas-y-tambores": "Banda de Sopros e Percussão",
     "musicStyles.banda-de-musica": "Banda",
     "musicStyles.batucada": "Batucada",

package/models/Instrument/group.js

@@ -17,9 +17,12 @@ class GroupInstrument extends _1.default {
         return GroupInstrument.isCustom(this.id);
     }
     get name() {
-        return GroupInstrument.isCustom(this.id) && this.id in this.groupInstruments
-            ? this.groupInstruments[this.id].name
-            : super.name;
+        if (!GroupInstrument.isCustom(this.id))
+            return super.name;
+        if (this.id in this.groupInstruments) {
+            return this.groupInstruments[this.id].name;
+        }
+        return (0, lang_1.getTranslation)('instruments.unknown', this.lang) || this.id;
     }
     get icon() {
         return GroupInstrument.isCustom(this.id) && this.id in this.groupInstruments

package/models/Instrument/index.d.ts

@@ -2,7 +2,7 @@ import { InstrumentId } from '../../helpers/instruments';
 import { LanguagesTypes } from '../../lang';
 export default class Instrument {
     id: InstrumentId;
-    private lang;
+    protected lang: LanguagesTypes;
     constructor(id: InstrumentId, lang?: LanguagesTypes);
     get name(): string;
     get icon(): string;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@glissandoo/lib",
-	"version": "1.56.0",
+	"version": "1.57.0",
 	"description": "Glissandoo library js",
 	"main": "./index.js",
 	"types": "./index.d.ts",