@glissandoo/lib 1.123.2 → 1.124.0-dev.219.1

package/helpers/compositionCategories/index.d.ts

@@ -0,0 +1,2 @@
+export * from './genres';
+export * from './styles';

package/helpers/compositionCategories/index.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./genres"), exports);
+__exportStar(require("./styles"), exports);

package/helpers/compositionCategories/styles.d.ts

@@ -0,0 +1,181 @@
+import { LeafIds } from '../dataStructures/trees/types';
+export declare const compositionStylesTree: {
+    readonly 'st-historical': {
+        readonly id: "st-historical";
+        readonly labelKey: "compositionStyles.group.historical";
+        readonly order: 0;
+    };
+    readonly 'st-jazz-blues': {
+        readonly id: "st-jazz-blues";
+        readonly labelKey: "compositionStyles.group.jazz_blues";
+        readonly order: 1;
+    };
+    readonly 'st-world-pop': {
+        readonly id: "st-world-pop";
+        readonly labelKey: "compositionStyles.group.world_pop";
+        readonly order: 2;
+    };
+    readonly 'st-character': {
+        readonly id: "st-character";
+        readonly labelKey: "compositionStyles.group.character";
+        readonly order: 3;
+    };
+    readonly 'st-renaissance': {
+        readonly id: "st-renaissance";
+        readonly parentId: "st-historical";
+        readonly labelKey: "compositionStyles.historical.renaissance";
+        readonly order: 0;
+    };
+    readonly 'st-baroque': {
+        readonly id: "st-baroque";
+        readonly parentId: "st-historical";
+        readonly labelKey: "compositionStyles.historical.baroque";
+        readonly order: 1;
+    };
+    readonly 'st-classicism': {
+        readonly id: "st-classicism";
+        readonly parentId: "st-historical";
+        readonly labelKey: "compositionStyles.historical.classicism";
+        readonly order: 2;
+    };
+    readonly 'st-romanticism': {
+        readonly id: "st-romanticism";
+        readonly parentId: "st-historical";
+        readonly labelKey: "compositionStyles.historical.romanticism";
+        readonly order: 3;
+    };
+    readonly 'st-post-romanticism': {
+        readonly id: "st-post-romanticism";
+        readonly parentId: "st-historical";
+        readonly labelKey: "compositionStyles.historical.post_romanticism";
+        readonly order: 4;
+    };
+    readonly 'st-20th-century': {
+        readonly id: "st-20th-century";
+        readonly parentId: "st-historical";
+        readonly labelKey: "compositionStyles.historical.20th_century";
+        readonly order: 5;
+    };
+    readonly 'st-contemporary': {
+        readonly id: "st-contemporary";
+        readonly parentId: "st-historical";
+        readonly labelKey: "compositionStyles.historical.contemporary";
+        readonly order: 6;
+    };
+    readonly 'st-minimalism': {
+        readonly id: "st-minimalism";
+        readonly parentId: "st-historical";
+        readonly labelKey: "compositionStyles.historical.minimalism";
+        readonly order: 7;
+    };
+    readonly 'st-swing': {
+        readonly id: "st-swing";
+        readonly parentId: "st-jazz-blues";
+        readonly labelKey: "compositionStyles.jazz.swing";
+        readonly order: 0;
+    };
+    readonly 'st-dixieland': {
+        readonly id: "st-dixieland";
+        readonly parentId: "st-jazz-blues";
+        readonly labelKey: "compositionStyles.jazz.dixieland";
+        readonly order: 1;
+    };
+    readonly 'st-bebop': {
+        readonly id: "st-bebop";
+        readonly parentId: "st-jazz-blues";
+        readonly labelKey: "compositionStyles.jazz.bebop";
+        readonly order: 2;
+    };
+    readonly 'st-fusion': {
+        readonly id: "st-fusion";
+        readonly parentId: "st-jazz-blues";
+        readonly labelKey: "compositionStyles.jazz.fusion";
+        readonly order: 3;
+    };
+    readonly 'st-blues': {
+        readonly id: "st-blues";
+        readonly parentId: "st-jazz-blues";
+        readonly labelKey: "compositionStyles.jazz.blues";
+        readonly order: 4;
+    };
+    readonly 'st-bossa': {
+        readonly id: "st-bossa";
+        readonly parentId: "st-jazz-blues";
+        readonly labelKey: "compositionStyles.jazz.bossa";
+        readonly order: 5;
+    };
+    readonly 'st-pop': {
+        readonly id: "st-pop";
+        readonly parentId: "st-world-pop";
+        readonly labelKey: "compositionStyles.world.pop";
+        readonly order: 0;
+    };
+    readonly 'st-rock': {
+        readonly id: "st-rock";
+        readonly parentId: "st-world-pop";
+        readonly labelKey: "compositionStyles.world.rock";
+        readonly order: 1;
+    };
+    readonly 'st-funk': {
+        readonly id: "st-funk";
+        readonly parentId: "st-world-pop";
+        readonly labelKey: "compositionStyles.world.funk";
+        readonly order: 2;
+    };
+    readonly 'st-flamenco': {
+        readonly id: "st-flamenco";
+        readonly parentId: "st-world-pop";
+        readonly labelKey: "compositionStyles.world.flamenco";
+        readonly order: 3;
+    };
+    readonly 'st-celtic': {
+        readonly id: "st-celtic";
+        readonly parentId: "st-world-pop";
+        readonly labelKey: "compositionStyles.world.celtic";
+        readonly order: 4;
+    };
+    readonly 'st-latin': {
+        readonly id: "st-latin";
+        readonly parentId: "st-world-pop";
+        readonly labelKey: "compositionStyles.world.latin";
+        readonly order: 5;
+    };
+    readonly 'st-african': {
+        readonly id: "st-african";
+        readonly parentId: "st-world-pop";
+        readonly labelKey: "compositionStyles.world.african";
+        readonly order: 6;
+    };
+    readonly 'st-oriental': {
+        readonly id: "st-oriental";
+        readonly parentId: "st-world-pop";
+        readonly labelKey: "compositionStyles.world.oriental";
+        readonly order: 7;
+    };
+    readonly 'st-epic': {
+        readonly id: "st-epic";
+        readonly parentId: "st-character";
+        readonly labelKey: "compositionStyles.character.epic";
+        readonly order: 0;
+    };
+    readonly 'st-sacred': {
+        readonly id: "st-sacred";
+        readonly parentId: "st-character";
+        readonly labelKey: "compositionStyles.character.sacred";
+        readonly order: 1;
+    };
+    readonly 'st-humorous': {
+        readonly id: "st-humorous";
+        readonly parentId: "st-character";
+        readonly labelKey: "compositionStyles.character.humorous";
+        readonly order: 2;
+    };
+    readonly 'st-solemn': {
+        readonly id: "st-solemn";
+        readonly parentId: "st-character";
+        readonly labelKey: "compositionStyles.character.solemn";
+        readonly order: 3;
+    };
+};
+export type CompositionStyleTreeKey = keyof typeof compositionStylesTree;
+export type CompositionStyleId = LeafIds<typeof compositionStylesTree>;

package/helpers/compositionCategories/styles.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compositionStylesTree = void 0;
+const types_1 = require("../dataStructures/trees/types");
+exports.compositionStylesTree = (0, types_1.defineTable)({
+    // ===========================================================================
+    // ROOT CATEGORIES
+    // ===========================================================================
+    'st-historical': {
+        id: 'st-historical',
+        labelKey: 'compositionStyles.group.historical',
+        order: 0,
+    },
+    'st-jazz-blues': {
+        id: 'st-jazz-blues',
+        labelKey: 'compositionStyles.group.jazz_blues',
+        order: 1,
+    },
+    'st-world-pop': {
+        id: 'st-world-pop',
+        labelKey: 'compositionStyles.group.world_pop',
+        order: 2,
+    },
+    'st-character': {
+        id: 'st-character',
+        labelKey: 'compositionStyles.group.character',
+        order: 3,
+    },
+    // ===========================================================================
+    // 1. HISTORICAL PERIODS
+    // ===========================================================================
+    'st-renaissance': {
+        id: 'st-renaissance',
+        parentId: 'st-historical',
+        labelKey: 'compositionStyles.historical.renaissance',
+        order: 0,
+    },
+    'st-baroque': {
+        id: 'st-baroque',
+        parentId: 'st-historical',
+        labelKey: 'compositionStyles.historical.baroque',
+        order: 1,
+    },
+    'st-classicism': {
+        id: 'st-classicism',
+        parentId: 'st-historical',
+        labelKey: 'compositionStyles.historical.classicism',
+        order: 2,
+    },
+    'st-romanticism': {
+        id: 'st-romanticism',
+        parentId: 'st-historical',
+        labelKey: 'compositionStyles.historical.romanticism',
+        order: 3,
+    },
+    'st-post-romanticism': {
+        id: 'st-post-romanticism',
+        parentId: 'st-historical',
+        labelKey: 'compositionStyles.historical.post_romanticism',
+        order: 4,
+    },
+    'st-20th-century': {
+        id: 'st-20th-century',
+        parentId: 'st-historical',
+        labelKey: 'compositionStyles.historical.20th_century',
+        order: 5,
+    },
+    'st-contemporary': {
+        id: 'st-contemporary',
+        parentId: 'st-historical',
+        labelKey: 'compositionStyles.historical.contemporary',
+        order: 6,
+    },
+    'st-minimalism': {
+        id: 'st-minimalism',
+        parentId: 'st-historical',
+        labelKey: 'compositionStyles.historical.minimalism',
+        order: 7,
+    },
+    // ===========================================================================
+    // 2. JAZZ & BLUES
+    // ===========================================================================
+    'st-swing': {
+        id: 'st-swing',
+        parentId: 'st-jazz-blues',
+        labelKey: 'compositionStyles.jazz.swing',
+        order: 0,
+    },
+    'st-dixieland': {
+        id: 'st-dixieland',
+        parentId: 'st-jazz-blues',
+        labelKey: 'compositionStyles.jazz.dixieland',
+        order: 1,
+    },
+    'st-bebop': {
+        id: 'st-bebop',
+        parentId: 'st-jazz-blues',
+        labelKey: 'compositionStyles.jazz.bebop',
+        order: 2,
+    },
+    'st-fusion': {
+        id: 'st-fusion',
+        parentId: 'st-jazz-blues',
+        labelKey: 'compositionStyles.jazz.fusion',
+        order: 3,
+    },
+    'st-blues': {
+        id: 'st-blues',
+        parentId: 'st-jazz-blues',
+        labelKey: 'compositionStyles.jazz.blues',
+        order: 4,
+    },
+    'st-bossa': {
+        id: 'st-bossa',
+        parentId: 'st-jazz-blues',
+        labelKey: 'compositionStyles.jazz.bossa',
+        order: 5,
+    },
+    // ===========================================================================
+    // 3. POPULAR & WORLD
+    // ===========================================================================
+    'st-pop': {
+        id: 'st-pop',
+        parentId: 'st-world-pop',
+        labelKey: 'compositionStyles.world.pop',
+        order: 0,
+    },
+    'st-rock': {
+        id: 'st-rock',
+        parentId: 'st-world-pop',
+        labelKey: 'compositionStyles.world.rock',
+        order: 1,
+    },
+    'st-funk': {
+        id: 'st-funk',
+        parentId: 'st-world-pop',
+        labelKey: 'compositionStyles.world.funk',
+        order: 2,
+    },
+    'st-flamenco': {
+        id: 'st-flamenco',
+        parentId: 'st-world-pop',
+        labelKey: 'compositionStyles.world.flamenco',
+        order: 3,
+    },
+    'st-celtic': {
+        id: 'st-celtic',
+        parentId: 'st-world-pop',
+        labelKey: 'compositionStyles.world.celtic',
+        order: 4,
+    },
+    'st-latin': {
+        id: 'st-latin',
+        parentId: 'st-world-pop',
+        labelKey: 'compositionStyles.world.latin',
+        order: 5,
+    },
+    'st-african': {
+        id: 'st-african',
+        parentId: 'st-world-pop',
+        labelKey: 'compositionStyles.world.african',
+        order: 6,
+    },
+    'st-oriental': {
+        id: 'st-oriental',
+        parentId: 'st-world-pop',
+        labelKey: 'compositionStyles.world.oriental',
+        order: 7,
+    },
+    // ===========================================================================
+    // 4. CHARACTER & FUNCTION
+    // ===========================================================================
+    'st-epic': {
+        id: 'st-epic',
+        parentId: 'st-character',
+        labelKey: 'compositionStyles.character.epic',
+        order: 0,
+    },
+    'st-sacred': {
+        id: 'st-sacred',
+        parentId: 'st-character',
+        labelKey: 'compositionStyles.character.sacred',
+        order: 1,
+    },
+    'st-humorous': {
+        id: 'st-humorous',
+        parentId: 'st-character',
+        labelKey: 'compositionStyles.character.humorous',
+        order: 2,
+    },
+    'st-solemn': {
+        id: 'st-solemn',
+        parentId: 'st-character',
+        labelKey: 'compositionStyles.character.solemn',
+        order: 3,
+    },
+});

package/helpers/compositionSoloistOffstageParts/index.d.ts

@@ -0,0 +1,34 @@
+import { DefaultInstrumentId } from '../instruments';
+import { LanguagesTypes } from '../../lang';
+export type SoloistOffstagePartType = 'soloist' | 'offstage';
+export interface SoloistOffstagePartInput {
+    partId?: string | null;
+    quantity?: number | null;
+    soloist?: boolean | null;
+    offstage?: boolean | null;
+}
+export interface SoloistOffstagePartFilterChip {
+    partId: DefaultInstrumentId;
+    quantity: number;
+    soloist: boolean;
+    offstage: boolean;
+}
+export type SoloistOffstagePartFilterMode = 'include' | 'exclude';
+export interface SoloistOffstagePartFilterSelection {
+    value: string;
+    mode: SoloistOffstagePartFilterMode;
+}
+export declare const getSoloistOffstagePartType: (part: Pick<SoloistOffstagePartInput, "soloist" | "offstage">) => SoloistOffstagePartType;
+export declare const getSoloistOffstagePartFlags: (type: SoloistOffstagePartType) => Pick<SoloistOffstagePartFilterChip, "soloist" | "offstage">;
+export declare const getSoloistOffstagePartKey: (part: Pick<SoloistOffstagePartFilterChip, "partId" | "soloist" | "offstage">) => string;
+export declare const getSoloistOffstagePartChipValue: (part: SoloistOffstagePartFilterChip) => string;
+export declare const getSoloistOffstagePartNameToken: (part: Pick<SoloistOffstagePartFilterChip, "partId" | "quantity">, lang?: LanguagesTypes) => string;
+export declare const normalizeSoloistOffstageParts: (parts?: SoloistOffstagePartInput[]) => SoloistOffstagePartFilterChip[];
+export declare const parseSoloistOffstagePartChipValue: (value: string) => SoloistOffstagePartFilterChip | null;
+export declare const matchesSoloistOffstagePartFilter: (part: SoloistOffstagePartFilterChip, filter: SoloistOffstagePartFilterChip) => boolean;
+export declare const hasSoloistOffstagePartFilterMatch: (parts: SoloistOffstagePartInput[] | undefined, filter: SoloistOffstagePartFilterChip) => boolean;
+export declare const mergeSoloistOffstagePartFilterSelections: (includeValues?: string[], excludeValues?: string[]) => SoloistOffstagePartFilterSelection[];
+export declare const splitSoloistOffstagePartFilterSelections: (selections?: SoloistOffstagePartFilterSelection[]) => {
+    include: string[];
+    exclude: string[];
+};

package/helpers/compositionSoloistOffstageParts/index.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitSoloistOffstagePartFilterSelections = exports.mergeSoloistOffstagePartFilterSelections = exports.hasSoloistOffstagePartFilterMatch = exports.matchesSoloistOffstagePartFilter = exports.parseSoloistOffstagePartChipValue = exports.normalizeSoloistOffstageParts = exports.getSoloistOffstagePartNameToken = exports.getSoloistOffstagePartChipValue = exports.getSoloistOffstagePartKey = exports.getSoloistOffstagePartFlags = exports.getSoloistOffstagePartType = void 0;
+const instruments_1 = require("../instruments");
+const lang_1 = require("../../lang");
+const Instrument_1 = __importDefault(require("../../models/Instrument"));
+const defaultInstrumentIds = new Set(Object.values(instruments_1.DefaultInstrumentId));
+const isDefaultInstrumentId = (value) => defaultInstrumentIds.has(value);
+const isValidQuantity = (quantity) => typeof quantity === 'number' && Number.isInteger(quantity) && quantity >= 1 && quantity <= 99;
+const getSoloistOffstagePartType = (part) => {
+    if (part.offstage)
+        return 'offstage';
+    return 'soloist';
+};
+exports.getSoloistOffstagePartType = getSoloistOffstagePartType;
+const getSoloistOffstagePartFlags = (type) => ({
+    soloist: type === 'soloist',
+    offstage: type === 'offstage',
+});
+exports.getSoloistOffstagePartFlags = getSoloistOffstagePartFlags;
+const toSoloistOffstagePart = (part) => {
+    if (!part ||
+        typeof part.partId !== 'string' ||
+        !isDefaultInstrumentId(part.partId) ||
+        !isValidQuantity(part.quantity) ||
+        typeof part.soloist !== 'boolean' ||
+        typeof part.offstage !== 'boolean') {
+        return null;
+    }
+    const flags = (0, exports.getSoloistOffstagePartFlags)((0, exports.getSoloistOffstagePartType)(part));
+    return {
+        partId: part.partId,
+        quantity: part.quantity,
+        soloist: flags.soloist,
+        offstage: flags.offstage,
+    };
+};
+const getSoloistOffstagePartKey = (part) => `${part.partId}|${(0, exports.getSoloistOffstagePartType)(part)}`;
+exports.getSoloistOffstagePartKey = getSoloistOffstagePartKey;
+const getSoloistOffstagePartChipValue = (part) => `${part.partId}|${part.quantity}|${part.soloist}|${part.offstage}`;
+exports.getSoloistOffstagePartChipValue = getSoloistOffstagePartChipValue;
+const getSoloistOffstagePartNameToken = (part, lang = lang_1.defaultLocale) => {
+    const instrument = new Instrument_1.default(part.partId, lang);
+    const name = instrument.getName(part.quantity);
+    return part.quantity > 1 ? name.toLocaleLowerCase(lang) : name;
+};
+exports.getSoloistOffstagePartNameToken = getSoloistOffstagePartNameToken;
+const normalizeSoloistOffstageParts = (parts = []) => {
+    const keyedParts = new Map();
+    parts.forEach((part) => {
+        const soloistOffstagePart = toSoloistOffstagePart(part);
+        if (!soloistOffstagePart)
+            return;
+        const key = (0, exports.getSoloistOffstagePartKey)(soloistOffstagePart);
+        if (!keyedParts.has(key)) {
+            keyedParts.set(key, soloistOffstagePart);
+        }
+    });
+    return [...keyedParts.values()].sort((a, b) => {
+        if (a.partId !== b.partId)
+            return a.partId.localeCompare(b.partId);
+        if (a.soloist !== b.soloist)
+            return Number(b.soloist) - Number(a.soloist);
+        return Number(b.offstage) - Number(a.offstage);
+    });
+};
+exports.normalizeSoloistOffstageParts = normalizeSoloistOffstageParts;
+const parseSoloistOffstagePartChipValue = (value) => {
+    const [partId, quantity, soloist, offstage, extra] = value.split('|');
+    if (extra !== undefined || !isDefaultInstrumentId(partId))
+        return null;
+    return toSoloistOffstagePart({
+        partId,
+        quantity: Number(quantity),
+        soloist: soloist === 'true' ? true : soloist === 'false' ? false : null,
+        offstage: offstage === 'true' ? true : offstage === 'false' ? false : null,
+    });
+};
+exports.parseSoloistOffstagePartChipValue = parseSoloistOffstagePartChipValue;
+const matchesSoloistOffstagePartFilter = (part, filter) => part.partId === filter.partId &&
+    (0, exports.getSoloistOffstagePartType)(part) === (0, exports.getSoloistOffstagePartType)(filter) &&
+    part.quantity >= filter.quantity;
+exports.matchesSoloistOffstagePartFilter = matchesSoloistOffstagePartFilter;
+const hasSoloistOffstagePartFilterMatch = (parts = [], filter) => (0, exports.normalizeSoloistOffstageParts)(parts).some((part) => (0, exports.matchesSoloistOffstagePartFilter)(part, filter));
+exports.hasSoloistOffstagePartFilterMatch = hasSoloistOffstagePartFilterMatch;
+const mergeSoloistOffstagePartFilterSelections = (includeValues = [], excludeValues = []) => {
+    const selectedValues = new Set();
+    const selections = [];
+    includeValues.forEach((value) => {
+        if (selectedValues.has(value))
+            return;
+        selectedValues.add(value);
+        selections.push({ value, mode: 'include' });
+    });
+    excludeValues.forEach((value) => {
+        if (selectedValues.has(value))
+            return;
+        selectedValues.add(value);
+        selections.push({ value, mode: 'exclude' });
+    });
+    return selections;
+};
+exports.mergeSoloistOffstagePartFilterSelections = mergeSoloistOffstagePartFilterSelections;
+const splitSoloistOffstagePartFilterSelections = (selections = []) => {
+    const modesByValue = new Map();
+    selections.forEach(({ value, mode }) => {
+        modesByValue.set(value, mode);
+    });
+    return [...modesByValue.entries()].reduce((result, [value, mode]) => {
+        result[mode].push(value);
+        return result;
+    }, { include: [], exclude: [] });
+};
+exports.splitSoloistOffstagePartFilterSelections = splitSoloistOffstagePartFilterSelections;

package/helpers/currency.d.ts

@@ -0,0 +1,23 @@
+import type { MarketplaceCurrencyCode } from './currencyConversion';
+export interface CurrencyInfo {
+    code: string;
+    symbol: string;
+    symbolIsCode: boolean;
+    prefixed: boolean;
+    decimalSeparator: string;
+}
+export interface CurrencyOption extends CurrencyInfo {
+    code: MarketplaceCurrencyCode;
+}
+export { MARKETPLACE_CURRENCY_CODES, MARKETPLACE_CURRENCY_SYMBOL_LOCALES, buildCurrencyConversionResult, convertCurrencyCents, getCurrencyForCountry, getDefaultMarketplaceCurrency, isSupportedMarketplaceCurrency, normalizeMarketplaceCurrency, roundMarketplaceCurrencyCents, } from './currencyConversion';
+export type { CurrencyConversionResult, CurrencyDefaultingInput, CurrencyExchangeRateSnapshot, MarketplaceCurrencyCode, } from './currencyConversion';
+export declare const DEFAULT_CURRENCY = "EUR";
+export declare const COUNTRY_TO_CURRENCY: Record<string, string>;
+export declare const countryToCurrency: (country: string | null | undefined) => string;
+export declare const getCurrencySymbol: (currency: string, locale?: string) => string;
+export declare const getCurrencyInfo: (currency: string) => CurrencyInfo;
+export declare const getMarketplaceCurrencyOptions: () => CurrencyOption[];
+export declare const formatCurrencyAmount: (amount: number, currency: string, fractionDigits?: number) => string;
+export declare const formatCurrencyCents: (cents: number | null | undefined, currency: string, fractionDigits?: number) => string;
+export declare const formatCurrencyInputValue: (value: string | number | undefined, currency: string) => string;
+export declare const parseCurrencyInputValue: (value: string | undefined, currency: string) => number;