@glissandoo/lib 1.114.1 → 1.115.0

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

@@ -42,8 +42,8 @@ var CollectionNames;
     CollectionNames["Inventory"] = "inventory";
     CollectionNames["InventoryItems"] = "inventoryItems";
     CollectionNames["Helpers"] = "helpers";
-})(CollectionNames = exports.CollectionNames || (exports.CollectionNames = {}));
+})(CollectionNames || (exports.CollectionNames = CollectionNames = {}));
 var HelpersDocNames;
 (function (HelpersDocNames) {
     HelpersDocNames["MinVersion"] = "minVersion";
-})(HelpersDocNames = exports.HelpersDocNames || (exports.HelpersDocNames = {}));
+})(HelpersDocNames || (exports.HelpersDocNames = HelpersDocNames = {}));

package/helpers/communicationTemplate/index.d.ts

@@ -1,11 +1,12 @@
 import { LanguagesTypes } from '../../lang';
+import { Descendant } from '../slate';
 export declare enum CommunicationTemplateType {
     NewGroup = "newGroup",
     NewMember = "newMember"
 }
 export interface CommunicationTemplateData {
     title: string;
-    message: any;
+    message: Descendant[];
 }
 export type CommunicationTemplateLangs = Record<LanguagesTypes, CommunicationTemplateData>;
 export interface CommunicationTemplatesVars {
@@ -28,5 +29,5 @@ export interface CommunicationTemplatesVars {
 }
 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 Record<string, any>, D extends Record<string, string>>(nodes: T[], meta: D): T[];
+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

@@ -3,14 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.replaceKeysVarsInNodes = exports.replaceKeysVarsString = exports.CommunicationTemplateType = void 0;
+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 || (exports.CommunicationTemplateType = {}));
+})(CommunicationTemplateType || (exports.CommunicationTemplateType = CommunicationTemplateType = {}));
 const templates = {
     newGroup: newGroup_1.default,
     newMember: newMember_1.default,
@@ -29,19 +30,18 @@ const replaceKeysVarsString = (text, meta) => {
 exports.replaceKeysVarsString = replaceKeysVarsString;
 function replaceKeysVarsInNodes(nodes, meta) {
     return nodes.map((node) => {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         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])) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 newNode[key] = replaceKeysVarsInNodes(newNode[key], meta);
             }
         }
         return newNode;
     });
 }
-exports.replaceKeysVarsInNodes = replaceKeysVarsInNodes;
 exports.default = templates;