@mpgd/catalog 0.7.8 → 0.8.0

package/dist/index.d.ts

@@ -55,6 +55,8 @@ export type AdPlacementEntry = (AdPlacementEntryBase & {
 export interface AdPlacements {
   readonly version: string;
   readonly placements: readonly AdPlacementEntry[];
+  /** Explicitly share a physical placement among logical placements of the same format. */
+  readonly sharedPlatformPlacementTargets?: readonly string[];
 }
 export declare const assertProductGrant: (input: unknown) => ProductGrant;
 export declare function assertProductCatalog(input: unknown): ProductCatalog;

package/dist/index.js

@@ -207,14 +207,14 @@ const assertAdPlacementsShape = (() => {
         path: _path + ".placements",
         expected: "ReadonlyArray<AdPlacementEntry>",
         value: input.placements
-    }, _errorFactory)) && input.placements.every((elem, _index2) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+    }, _errorFactory)) && input.placements.every((elem, _index3) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
-        path: _path + ".placements[" + _index2 + "]",
+        path: _path + ".placements[" + _index3 + "]",
         expected: _ae0,
         value: elem
-    }, _errorFactory)) && _au0(elem, _path + ".placements[" + _index2 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _au0(elem, _path + ".placements[" + _index3 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
-        path: _path + ".placements[" + _index2 + "]",
+        path: _path + ".placements[" + _index3 + "]",
         expected: _ae0,
         value: elem
     }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -222,6 +222,21 @@ const assertAdPlacementsShape = (() => {
         path: _path + ".placements",
         expected: "ReadonlyArray<AdPlacementEntry>",
         value: input.placements
+    }, _errorFactory)) && (undefined === input.sharedPlatformPlacementTargets || (Array.isArray(input.sharedPlatformPlacementTargets) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".sharedPlatformPlacementTargets",
+        expected: "(ReadonlyArray<string> | undefined)",
+        value: input.sharedPlatformPlacementTargets
+    }, _errorFactory)) && input.sharedPlatformPlacementTargets.every((elem, _index4) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".sharedPlatformPlacementTargets[" + _index4 + "]",
+        expected: "string",
+        value: elem
+    }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".sharedPlatformPlacementTargets",
+        expected: "(ReadonlyArray<string> | undefined)",
+        value: input.sharedPlatformPlacementTargets
     }, _errorFactory));
     const _ao1 = (input, _path, _exceptionable = true) => _ao2(input, _path, true && _exceptionable) && (("rewarded" === input.type || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
@@ -351,7 +366,7 @@ const assertAdPlacementsShape = (() => {
                 value: input
             }, _errorFactory);
     })();
-    const _io0 = input => "string" === typeof input.version && (Array.isArray(input.placements) && input.placements.every(elem => "object" === typeof elem && null !== elem && _iu0(elem)));
+    const _io0 = input => "string" === typeof input.version && (Array.isArray(input.placements) && input.placements.every(elem => "object" === typeof elem && null !== elem && _iu0(elem))) && (undefined === input.sharedPlatformPlacementTargets || Array.isArray(input.sharedPlatformPlacementTargets) && input.sharedPlatformPlacementTargets.every(elem => "string" === typeof elem));
     const _io1 = input => _io2(input) && ("rewarded" === input.type && (undefined === input.reward || "object" === typeof input.reward && null !== input.reward && _iu1(input.reward)));
     const _io2 = input => "string" === typeof input.id && ("object" === typeof input.frequencyCap && null !== input.frequencyCap && _io3(input.frequencyCap)) && ("object" === typeof input.platformPlacementIds && null !== input.platformPlacementIds && false === Array.isArray(input.platformPlacementIds) && _io4(input.platformPlacementIds));
     const _io3 = input => "number" === typeof input.cooldownSeconds && (undefined === input.maxPerSession || "number" === typeof input.maxPerSession) && (undefined === input.minStageInterval || "number" === typeof input.minStageInterval);
@@ -518,10 +533,16 @@ export function assertProductCatalog(input) {
 }
 export function assertAdPlacements(input) {
     const placements = assertAdPlacementsShape(input);
+    const sharingTargets = new Set(placements.sharedPlatformPlacementTargets ?? []);
+    if (sharingTargets.size !== (placements.sharedPlatformPlacementTargets?.length ?? 0)
+        || [...sharingTargets].some((target) => target.trim() !== target || target.length === 0)) {
+        throw new Error('Shared placement targets must be unique non-empty identifiers.');
+    }
     assertUniqueNormalizedPlatformIdentifiers(placements.placements.map((placement) => ({
         logicalId: placement.id,
         identifiers: placement.platformPlacementIds,
-    })), 'ad placement');
+        format: placement.type,
+    })), 'ad placement', sharingTargets);
     return placements;
 }
 export function resolveProductPlatformId(product, target) {
@@ -540,7 +561,7 @@ function normalizePlatformIdentifier(identifier) {
     const normalized = identifier?.trim();
     return normalized === undefined || normalized.length === 0 ? undefined : normalized;
 }
-function assertUniqueNormalizedPlatformIdentifiers(entries, kind) {
+function assertUniqueNormalizedPlatformIdentifiers(entries, kind, sharingTargets = new Set()) {
     const identifiersByTarget = new Map();
     for (const entry of entries) {
         for (const [target, identifier] of Object.entries(entry.identifiers)) {
@@ -549,12 +570,15 @@ function assertUniqueNormalizedPlatformIdentifiers(entries, kind) {
                 continue;
             }
             const targetIdentifiers = identifiersByTarget.get(target) ?? new Map();
-            const existingLogicalId = targetIdentifiers.get(normalized);
-            if (existingLogicalId !== undefined) {
+            const existing = targetIdentifiers.get(normalized);
+            if (existing !== undefined && (!sharingTargets.has(target) || existing.format !== entry.format)) {
                 throw new Error(`Duplicate normalized ${kind} platform identifier ${normalized} for target ${target}: `
-                    + `${existingLogicalId} and ${entry.logicalId}.`);
+                    + `${existing.logicalId} and ${entry.logicalId}.`);
             }
-            targetIdentifiers.set(normalized, entry.logicalId);
+            targetIdentifiers.set(normalized, {
+                logicalId: entry.logicalId,
+                ...(entry.format === undefined ? {} : { format: entry.format }),
+            });
             identifiersByTarget.set(target, targetIdentifiers);
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/catalog",
-  "version": "0.7.8",
+  "version": "0.8.0",
   "description": "Product catalog and ad placement configuration schemas for mpgd games.",
   "license": "MIT",
   "repository": {
@@ -39,7 +39,7 @@
   ],
   "dependencies": {
     "typia": "13.0.2",
-    "@mpgd/platform": "0.16.0"
+    "@mpgd/platform": "0.17.0"
   },
   "devDependencies": {
     "ttsc": "0.30.4",