@glissandoo/lib 1.123.2 → 1.124.0-dev.219.1

package/helpers/catalogBridge.d.ts

@@ -0,0 +1,121 @@
+import { MarketplaceCurrencyCode } from './currencyConversion';
+export type CatalogProductType = 'Score' | 'Parts' | 'ScoreAndParts';
+export declare enum CatalogBridgeEventType {
+    Ready = "catalog:ready",
+    Init = "catalog:init",
+    Navigate = "catalog:navigate",
+    Back = "catalog:back",
+    Height = "catalog:height",
+    State = "catalog:state",
+    Error = "catalog:error",
+    FavoriteSet = "catalog:favorite:set",
+    Purchase = "catalog:purchase",
+    Obtain = "catalog:obtain",
+    InvoiceOpen = "catalog:invoice:open",
+    RepertoryOpen = "catalog:repertory:open",
+    Report = "catalog:report",
+    CurrencyChange = "catalog:currency:change",
+    OverlayOpen = "catalog:overlay:open",
+    OverlayClose = "catalog:overlay:close"
+}
+export type CatalogDashboardView = 'explore' | 'favorites' | 'acquired' | 'composers' | 'composition-detail' | 'composer-detail' | 'success';
+export type CatalogIframeView = Exclude<CatalogDashboardView, 'success'>;
+export interface CatalogBridgeState {
+    favoriteIds: string[];
+    acquiredCompositionIds: string[];
+    acquiredProductTypesByCompositionId?: Partial<Record<string, CatalogProductType[]>>;
+    acquisitionInfoByCompositionId?: Partial<Record<string, {
+        acquisitionId: string;
+        acquiredByUserId?: string;
+        acquiredByUserName?: string;
+        acquiredByGroupId?: string;
+        acquiredByGroupName?: string;
+        acquiredProducts: Partial<Record<CatalogProductType, {
+            acquiredAt: string;
+            amountPaid?: number;
+            currency?: string;
+        }>>;
+    }>>;
+    permissions: {
+        canAcquire: boolean;
+        canPurchase: boolean;
+    };
+    locale: string;
+    buyerCurrency?: MarketplaceCurrencyCode;
+    view?: CatalogDashboardView;
+    pendingCatalogProductAction?: {
+        compositionId: string;
+        productType: CatalogProductType;
+    };
+    groupMusicStyle?: string | null;
+    groupCountry?: string | null;
+    sidebarCollapsed?: boolean;
+    parentOrigin?: string;
+}
+export type CatalogBridgeOverlay = {
+    kind: 'audio';
+    title: string;
+    url: string;
+} | {
+    kind: 'youtube';
+    title: string;
+    videoId: string;
+} | {
+    kind: 'richTextDrawer';
+    title: string;
+    content: unknown;
+    width?: number;
+} | {
+    kind: 'imageGallery';
+    title: string;
+    images: {
+        url: string;
+        alt?: string;
+    }[];
+    currentIndex?: number;
+};
+export type CatalogBridgeAction = {
+    type: CatalogBridgeEventType.FavoriteSet;
+    compositionId: string;
+    favorite: boolean;
+} | {
+    type: CatalogBridgeEventType.Purchase | CatalogBridgeEventType.Obtain;
+    compositionId?: string;
+    composerId?: string;
+    productType: CatalogProductType;
+    buyerCurrency?: MarketplaceCurrencyCode;
+} | {
+    type: CatalogBridgeEventType.InvoiceOpen;
+    compositionId?: string;
+} | {
+    type: CatalogBridgeEventType.RepertoryOpen;
+    compositionId?: string;
+    acquisitionId?: string;
+    compositionTitle?: string;
+} | {
+    type: CatalogBridgeEventType.Report;
+    subject: string;
+    body: string;
+} | {
+    type: CatalogBridgeEventType.CurrencyChange;
+    buyerCurrency: MarketplaceCurrencyCode;
+} | {
+    type: CatalogBridgeEventType.OverlayOpen;
+    overlay: CatalogBridgeOverlay;
+} | {
+    type: CatalogBridgeEventType.OverlayClose;
+} | {
+    type: CatalogBridgeEventType.Navigate;
+    path: string;
+} | {
+    type: CatalogBridgeEventType.Back;
+    fallbackPath: string;
+};
+export interface CatalogBridgeEvent<Payload = unknown> {
+    type: CatalogBridgeEventType;
+    requestId?: string;
+    payload?: Payload;
+}
+export declare const isCatalogBridgeEvent: (value: unknown) => value is CatalogBridgeEvent;
+export declare const isCatalogBridgeAction: (value: unknown) => value is CatalogBridgeAction;
+export declare const isCatalogStateEvent: (value: unknown) => value is CatalogBridgeEvent<CatalogBridgeState>;

package/helpers/catalogBridge.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCatalogStateEvent = exports.isCatalogBridgeAction = exports.isCatalogBridgeEvent = exports.CatalogBridgeEventType = void 0;
+const currencyConversion_1 = require("./currencyConversion");
+var CatalogBridgeEventType;
+(function (CatalogBridgeEventType) {
+    CatalogBridgeEventType["Ready"] = "catalog:ready";
+    CatalogBridgeEventType["Init"] = "catalog:init";
+    CatalogBridgeEventType["Navigate"] = "catalog:navigate";
+    CatalogBridgeEventType["Back"] = "catalog:back";
+    CatalogBridgeEventType["Height"] = "catalog:height";
+    CatalogBridgeEventType["State"] = "catalog:state";
+    CatalogBridgeEventType["Error"] = "catalog:error";
+    CatalogBridgeEventType["FavoriteSet"] = "catalog:favorite:set";
+    CatalogBridgeEventType["Purchase"] = "catalog:purchase";
+    CatalogBridgeEventType["Obtain"] = "catalog:obtain";
+    CatalogBridgeEventType["InvoiceOpen"] = "catalog:invoice:open";
+    CatalogBridgeEventType["RepertoryOpen"] = "catalog:repertory:open";
+    CatalogBridgeEventType["Report"] = "catalog:report";
+    CatalogBridgeEventType["CurrencyChange"] = "catalog:currency:change";
+    CatalogBridgeEventType["OverlayOpen"] = "catalog:overlay:open";
+    CatalogBridgeEventType["OverlayClose"] = "catalog:overlay:close";
+})(CatalogBridgeEventType || (exports.CatalogBridgeEventType = CatalogBridgeEventType = {}));
+const productTypes = ['Score', 'Parts', 'ScoreAndParts'];
+const isObject = (value) => typeof value === 'object' && value !== null;
+const isString = (value) => typeof value === 'string';
+const isOptionalString = (value) => value === undefined || isString(value);
+const isOptionalNumber = (value) => value === undefined || typeof value === 'number';
+const isBoolean = (value) => typeof value === 'boolean';
+const isProductType = (value) => isString(value) && productTypes.includes(value);
+const isOptionalBuyerCurrency = (value) => value === undefined || (0, currencyConversion_1.isSupportedMarketplaceCurrency)(value);
+const isCatalogBridgeOverlay = (value) => {
+    if (!isObject(value) || !isString(value.kind) || !isString(value.title)) {
+        return false;
+    }
+    switch (value.kind) {
+        case 'audio':
+            return isString(value.url);
+        case 'youtube':
+            return isString(value.videoId);
+        case 'richTextDrawer':
+            return 'content' in value && isOptionalNumber(value.width);
+        case 'imageGallery':
+            return (Array.isArray(value.images) &&
+                value.images.every((image) => isObject(image) && isString(image.url) && isOptionalString(image.alt)) &&
+                isOptionalNumber(value.currentIndex));
+        default:
+            return false;
+    }
+};
+const isCatalogBridgeEvent = (value) => isObject(value) &&
+    isString(value.type) &&
+    Object.values(CatalogBridgeEventType).includes(value.type);
+exports.isCatalogBridgeEvent = isCatalogBridgeEvent;
+const isCatalogBridgeAction = (value) => {
+    if (!isObject(value) ||
+        !isString(value.type) ||
+        !Object.values(CatalogBridgeEventType).includes(value.type)) {
+        return false;
+    }
+    const eventType = value.type;
+    switch (eventType) {
+        case CatalogBridgeEventType.FavoriteSet:
+            return isString(value.compositionId) && isBoolean(value.favorite);
+        case CatalogBridgeEventType.Purchase:
+        case CatalogBridgeEventType.Obtain:
+            return (isOptionalString(value.compositionId) &&
+                isOptionalString(value.composerId) &&
+                isProductType(value.productType) &&
+                isOptionalBuyerCurrency(value.buyerCurrency));
+        case CatalogBridgeEventType.InvoiceOpen:
+            return isOptionalString(value.compositionId);
+        case CatalogBridgeEventType.RepertoryOpen:
+            return (isOptionalString(value.compositionId) &&
+                isOptionalString(value.acquisitionId) &&
+                isOptionalString(value.compositionTitle));
+        case CatalogBridgeEventType.Report:
+            return isString(value.subject) && isString(value.body);
+        case CatalogBridgeEventType.CurrencyChange:
+            return (0, currencyConversion_1.isSupportedMarketplaceCurrency)(value.buyerCurrency);
+        case CatalogBridgeEventType.OverlayOpen:
+            return isCatalogBridgeOverlay(value.overlay);
+        case CatalogBridgeEventType.OverlayClose:
+            return true;
+        case CatalogBridgeEventType.Navigate:
+            return isString(value.path);
+        case CatalogBridgeEventType.Back:
+            return isString(value.fallbackPath);
+        default:
+            return false;
+    }
+};
+exports.isCatalogBridgeAction = isCatalogBridgeAction;
+const isCatalogStateEvent = (value) => (0, exports.isCatalogBridgeEvent)(value) && value.type === CatalogBridgeEventType.State;
+exports.isCatalogStateEvent = isCatalogStateEvent;

package/helpers/collections.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HelpersDocNames = exports.CollectionNames = void 0;
+var CollectionNames;
+(function (CollectionNames) {
+    CollectionNames["Communication"] = "communication";
+    CollectionNames["CommunicationComments"] = "comments";
+    CollectionNames["Customer"] = "customer";
+    CollectionNames["CustomerGroups"] = "groups";
+    CollectionNames["Notification"] = "notification";
+    CollectionNames["User"] = "user";
+    CollectionNames["UserGroups"] = "groups";
+    CollectionNames["UserPartnerships"] = "partnerships";
+    CollectionNames["UserNotifications"] = "notifications";
+    CollectionNames["UserOfferAlarms"] = "offerAlarms";
+    CollectionNames["Counters"] = "database";
+    CollectionNames["Records"] = "records";
+    CollectionNames["Event"] = "event";
+    CollectionNames["EventPlayers"] = "players";
+    CollectionNames["EventRepertory"] = "repertory";
+    CollectionNames["Group"] = "group";
+    CollectionNames["GroupEvents"] = "events";
+    CollectionNames["GroupPlayers"] = "players";
+    CollectionNames["GroupAnalytics"] = "analytics";
+    CollectionNames["GroupPlayerEvents"] = "events";
+    CollectionNames["GroupRepertory"] = "repertory";
+    CollectionNames["GroupStageTemplates"] = "stageTemplates";
+    CollectionNames["Metrics"] = "metrics";
+    CollectionNames["Partnership"] = "partnership";
+    CollectionNames["PartnershipGroup"] = "partnershipGroup";
+    CollectionNames["PartnershipPartner"] = "partnershipPartner";
+    CollectionNames["PartnershipPlan"] = "partnershipPlan";
+    CollectionNames["PartnershipSubscription"] = "partnershipSubscription";
+    CollectionNames["PartnershipPayment"] = "partnershipPayment";
+    CollectionNames["PartnershipSepaPaymentGroup"] = "partnershipSepaPaymentGroup";
+    CollectionNames["PartnershipCommunication"] = "partnershipCommunication";
+    CollectionNames["Federation"] = "federation";
+    CollectionNames["FederationPartnerships"] = "partnerships";
+    CollectionNames["Offer"] = "offer";
+    CollectionNames["OfferApplicants"] = "applicants";
+    CollectionNames["WebhookEvent"] = "webhookEvent";
+    CollectionNames["Inventory"] = "inventory";
+    CollectionNames["InventoryItems"] = "inventoryItems";
+    CollectionNames["Helpers"] = "helpers";
+})(CollectionNames || (exports.CollectionNames = CollectionNames = {}));
+var HelpersDocNames;
+(function (HelpersDocNames) {
+    HelpersDocNames["MinVersion"] = "minVersion";
+})(HelpersDocNames || (exports.HelpersDocNames = HelpersDocNames = {}));

package/helpers/communicationTemplate/index.d.ts

@@ -0,0 +1,33 @@
+import { LanguagesTypes } from '../../lang';
+import { Descendant } from '../slate';
+export declare enum CommunicationTemplateType {
+    NewGroup = "newGroup",
+    NewMember = "newMember"
+}
+export interface CommunicationTemplateData {
+    title: string;
+    message: Descendant[];
+}
+export type CommunicationTemplateLangs = Record<LanguagesTypes, CommunicationTemplateData>;
+export interface CommunicationTemplatesVars {
+    [CommunicationTemplateType.NewGroup]: {
+        title: {
+            name: string;
+        };
+        message: Record<string, never>;
+    };
+    [CommunicationTemplateType.NewMember]: {
+        title: {
+            userName: string;
+        };
+        message: {
+            userDisplayName: string;
+            userInstrument: string;
+            groupDisplayName: string;
+        };
+    };
+}
+declare const templates: Record<CommunicationTemplateType, CommunicationTemplateLangs>;
+export declare const replaceKeysVarsString: <T extends string, D extends Record<string, string>>(text: T, meta: D) => string;
+export declare function replaceKeysVarsInNodes<T extends Descendant, D extends Record<string, string>>(nodes: T[], meta: D): T[];
+export default templates;

package/helpers/communicationTemplate/index.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceKeysVarsString = exports.CommunicationTemplateType = void 0;
+exports.replaceKeysVarsInNodes = replaceKeysVarsInNodes;
+const newGroup_1 = __importDefault(require("./newGroup"));
+const newMember_1 = __importDefault(require("./newMember"));
+var CommunicationTemplateType;
+(function (CommunicationTemplateType) {
+    CommunicationTemplateType["NewGroup"] = "newGroup";
+    CommunicationTemplateType["NewMember"] = "newMember";
+})(CommunicationTemplateType || (exports.CommunicationTemplateType = CommunicationTemplateType = {}));
+const templates = {
+    newGroup: newGroup_1.default,
+    newMember: newMember_1.default,
+};
+const replaceKeysVarsString = (text, meta) => {
+    const matches = text.match(/(\{).+?(\})/g);
+    if (!matches || matches.length === 0)
+        return text;
+    return matches.reduce((text, match) => {
+        const key = match.slice(1, -1);
+        if (!(key in meta))
+            return text;
+        return text.replace(match, meta[key]);
+    }, text);
+};
+exports.replaceKeysVarsString = replaceKeysVarsString;
+function replaceKeysVarsInNodes(nodes, meta) {
+    return nodes.map((node) => {
+        const newNode = { ...node };
+        for (const key in newNode) {
+            if (typeof newNode[key] === 'string') {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore — typeof guard narrows this, but TS <5.9 can't infer it
+                newNode[key] = (0, exports.replaceKeysVarsString)(newNode[key], meta);
+            }
+            else if (Array.isArray(newNode[key])) {
+                newNode[key] = replaceKeysVarsInNodes(newNode[key], meta);
+            }
+        }
+        return newNode;
+    });
+}
+exports.default = templates;