@mpgd/target-config 0.10.0 → 0.10.1

package/dist/effective.d.ts

@@ -1,4 +1,4 @@
-import type { AdPlacementEntry, AdPlacements, ProductCatalog, ProductCatalogEntry } from '@mpgd/catalog';
+import { type AdPlacementEntry, type AdPlacements, type ProductCatalog, type ProductCatalogEntry } from '@mpgd/catalog';
 import { type FeatureAvailabilityReason, type TargetCapabilityConfig, type TargetConfig, type TargetConfigMatrix, type TargetFeatureConfig, type TargetIntegrationConfig, type TargetLocalizationConfig, type TargetPolicyRestrictions, type TargetReleaseConfig, type TargetRuntimeKind } from './runtime.js';
 export type EffectiveAvailabilityReason = FeatureAvailabilityReason | 'missing-platform-id';
 export interface EffectivePlatformTargetMetadata {

package/dist/effective.js

@@ -1,4 +1,5 @@
-import { normalizeTargetIntegrationConfig, } from './runtime.js';
+import { resolveAdPlacementPlatformId, resolveProductPlatformId, } from '@mpgd/catalog';
+import { assertTargetIntegrationRuntimeBounds, } from './runtime.js';
 export const defaultLeaderboardId = 'default';
 const disabledAuthoritativeMonetization = {
     iap: false,
@@ -10,10 +11,10 @@ export function createEffectiveTargetConfig(input) {
     const products = input.catalog.products.map((product) => createEffectiveProductConfig(input.target, config, product));
     const placements = input.adPlacements.placements.map((placement) => createEffectiveAdPlacementConfig(input.target, config, placement));
     const leaderboardEnabled = config.features.leaderboard;
-    const integrations = normalizeTargetIntegrationConfig({
+    const integrations = assertTargetIntegrationRuntimeBounds(config.runtime, {
         ...config.integrations,
         ...input.platformTarget?.integrations,
-    });
+    }, `Effective target ${input.target}`);
     return {
         version: effectiveTargetConfigVersion({
             targetConfig: input.targetConfigVersion,
@@ -107,8 +108,8 @@ export function getEffectiveAdPlacementConfig(config, placementId) {
     return config.ads.placements.find((placement) => placement.id === placementId);
 }
 function createEffectiveProductConfig(target, config, product) {
-    const platformProductId = productPlatformId(product, target);
-    const reason = effectiveProductReason(target, config.features.iap, product, platformProductId);
+    const platformProductId = resolveProductPlatformId(product, target);
+    const reason = effectiveProductReason(config.runtime, config.features.iap, product, platformProductId);
     return {
         id: product.id,
         type: product.type,
@@ -118,11 +119,11 @@ function createEffectiveProductConfig(target, config, product) {
         ...(platformProductId === undefined ? {} : { platformProductId }),
     };
 }
-function effectiveProductReason(target, targetEnabled, product, platformProductId) {
+function effectiveProductReason(runtime, targetEnabled, product, platformProductId) {
     if (!targetEnabled) {
         return 'target-disabled';
     }
-    if (target === 'verse8' && product.grant.type === 'resource') {
+    if (runtime === 'verse8-web' && product.grant.type === 'resource') {
         return 'capability-unsupported';
     }
     return effectiveItemReason(targetEnabled, platformProductId);
@@ -131,7 +132,7 @@ function createEffectiveAdPlacementConfig(target, config, placement) {
     const featureEnabled = isRewardedPlacement(placement)
         ? config.features.rewardedAds
         : config.features.interstitialAds;
-    const platformPlacementId = adPlacementPlatformId(placement, target);
+    const platformPlacementId = resolveAdPlacementPlatformId(placement, target);
     const reason = effectiveItemReason(featureEnabled, platformPlacementId);
     return {
         id: placement.id,
@@ -152,35 +153,6 @@ function effectiveItemReason(targetEnabled, platformId) {
 function effectiveTargetConfigVersion(input) {
     return `${input.targetConfig}+catalog.${input.productCatalog}+ads.${input.adPlacements}`;
 }
-function productPlatformId(product, target) {
-    if (!isProductStoreTarget(target)) {
-        return undefined;
-    }
-    return normalizePlatformId(product.platformProductIds[target]);
-}
-function adPlacementPlatformId(placement, target) {
-    if (!isAdStoreTarget(target)) {
-        return undefined;
-    }
-    return normalizePlatformId(placement.platformPlacementIds[target]);
-}
-function normalizePlatformId(platformId) {
-    if (platformId === undefined) {
-        return undefined;
-    }
-    const trimmed = platformId.trim();
-    return trimmed.length === 0 ? undefined : trimmed;
-}
-function isProductStoreTarget(target) {
-    return target === 'android'
-        || target === 'ios'
-        || target === 'ait'
-        || target === 'reddit'
-        || target === 'verse8';
-}
-function isAdStoreTarget(target) {
-    return target === 'android' || target === 'ios' || target === 'ait' || target === 'verse8';
-}
 function isRewardedPlacement(placement) {
     return placement.type === 'rewarded';
 }

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import type { EffectiveTargetConfigMatrix } from './effective.js';
 import type { TargetConfigMatrix } from './runtime.js';
 export * from './effective.js';
+export * from './releaseIdentity.js';
 export * from './runtime.js';
 export * from './viewport.js';
 export declare const assertEffectiveTargetConfigMatrix: (input: unknown) => EffectiveTargetConfigMatrix;

package/dist/index.js

@@ -3,6 +3,7 @@ import * as _accessExpressionAsString_1 from "typia/lib/internal/_accessExpressi
 const __typia_transform__accessExpressionAsString = _accessExpressionAsString_1._accessExpressionAsString;
 import typia from 'typia';
 export * from './effective.js';
+export * from './releaseIdentity.js';
 export * from './runtime.js';
 export * from './viewport.js';
 export const assertEffectiveTargetConfigMatrix = (() => {

package/dist/releaseIdentity.d.ts

@@ -0,0 +1,33 @@
+/**
+* A human-facing release identity shared by every target artifact for one game release.
+*
+* `gameVersion` remains the game's SemVer value. `releaseRevision` is deliberately
+* separate so a game can keep one semantic release while targets are promoted or
+* rebuilt independently. For example, the common label for game `0.3.30` and
+* revision `42` is `0.3.30-v42`.
+*/
+export interface MpgdReleaseIdentity {
+  readonly gameVersion: string;
+  readonly releaseRevision?: number;
+  readonly label: string;
+}
+export interface CreateMpgdReleaseIdentityInput {
+  readonly gameVersion: string;
+  readonly releaseRevision?: number;
+  /**
+  * Optional value from a build environment. It must equal the derived label so
+  * a stale or hand-edited label cannot be embedded into an artifact.
+  */
+  readonly expectedLabel?: string;
+}
+export declare function createMpgdReleaseIdentity(input: CreateMpgdReleaseIdentityInput): MpgdReleaseIdentity;
+export declare function formatMpgdReleaseLabel(gameVersion: string, releaseRevision: number | undefined): string;
+/** Whether a normalized game version is eligible for an immutable production release. */
+export declare function isMpgdFinalSemVer(value: string): boolean;
+/**
+* Canonical release-manifest identifier derived from a common release label.
+* Both components must be non-empty canonical tokens without the `+` delimiter.
+*/
+export declare function formatMpgdReleaseId(label: string, buildId: string): string;
+/** Parse an optional release revision without making empty values meaningful. */
+export declare function parseMpgdReleaseRevision(value: string | undefined): number | undefined;

package/dist/releaseIdentity.js

@@ -0,0 +1,80 @@
+const semVerCore = '(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)';
+const preReleaseNumericIdentifier = '(?:0|[1-9]\\d*)';
+const preReleaseAlphanumericIdentifier = '(?:\\d*[A-Za-z-][0-9A-Za-z-]*)';
+const preReleaseIdentifier = `(?:${preReleaseNumericIdentifier}|${preReleaseAlphanumericIdentifier})`;
+const finalSemVerPattern = new RegExp(`^${semVerCore}$`, 'u');
+const semVerPattern = new RegExp(`^${semVerCore}(?:-${preReleaseIdentifier}(?:\\.${preReleaseIdentifier})*)?$`, 'u');
+export function createMpgdReleaseIdentity(input) {
+    const gameVersion = normalizeMpgdSemVer(input.gameVersion);
+    const releaseRevision = input.releaseRevision;
+    const label = formatNormalizedMpgdReleaseLabel(gameVersion, releaseRevision);
+    const expectedLabel = input.expectedLabel?.trim();
+    if (expectedLabel !== undefined && expectedLabel !== label) {
+        const detail = `${label}; received ${expectedLabel}.`;
+        throw new TypeError(`Release identity label must equal ${detail}`);
+    }
+    return releaseRevision === undefined
+        ? { gameVersion, label }
+        : { gameVersion, releaseRevision, label };
+}
+export function formatMpgdReleaseLabel(gameVersion, releaseRevision) {
+    return formatNormalizedMpgdReleaseLabel(normalizeMpgdSemVer(gameVersion), releaseRevision);
+}
+function formatNormalizedMpgdReleaseLabel(gameVersion, releaseRevision) {
+    if (releaseRevision === undefined) {
+        return gameVersion;
+    }
+    if (!isMpgdFinalSemVer(gameVersion)) {
+        throw new TypeError('Release identity gameVersion must be a final SemVer when releaseRevision is set.');
+    }
+    if (!Number.isSafeInteger(releaseRevision) || releaseRevision < 1) {
+        throw new TypeError('Release identity releaseRevision must be a positive safe integer.');
+    }
+    return `${gameVersion}-v${releaseRevision}`;
+}
+/** Whether a normalized game version is eligible for an immutable production release. */
+export function isMpgdFinalSemVer(value) {
+    return finalSemVerPattern.test(value);
+}
+/**
+ * Canonical release-manifest identifier derived from a common release label.
+ * Both components must be non-empty canonical tokens without the `+` delimiter.
+ */
+export function formatMpgdReleaseId(label, buildId) {
+    assertReleaseIdComponent(label, 'label');
+    assertReleaseIdComponent(buildId, 'buildId');
+    return `mpgd-${label}+${buildId}`;
+}
+/** Parse an optional release revision without making empty values meaningful. */
+export function parseMpgdReleaseRevision(value) {
+    if (value === undefined || value.trim().length === 0) {
+        return undefined;
+    }
+    const normalized = value.trim();
+    if (!/^[1-9]\d*$/u.test(normalized)) {
+        throw new TypeError('Release revision must be a positive safe integer.');
+    }
+    const releaseRevision = Number.parseInt(normalized, 10);
+    if (!Number.isSafeInteger(releaseRevision)) {
+        throw new TypeError('Release revision must be a positive safe integer.');
+    }
+    return releaseRevision;
+}
+function normalizeMpgdSemVer(value) {
+    const normalized = value.trim();
+    if (normalized.includes('+')) {
+        throw new TypeError('Release identity gameVersion must not contain SemVer build metadata because "+" is reserved for release IDs.');
+    }
+    if (!semVerPattern.test(normalized)) {
+        throw new TypeError('Release identity gameVersion must be a SemVer value.');
+    }
+    return normalized;
+}
+function assertReleaseIdComponent(value, label) {
+    if (value.length === 0 || /\s/u.test(value)) {
+        throw new TypeError(`Release identifier ${label} must be a non-empty canonical token.`);
+    }
+    if (value.includes('+')) {
+        throw new TypeError(`Release identifier ${label} must not contain "+".`);
+    }
+}

package/dist/runtime.d.ts

@@ -128,6 +128,7 @@ export declare const defaultTargetIntegrationConfig: {
   readonly presentationMode: 'fullscreen';
 };
 export declare function normalizeTargetIntegrationConfig(config: Partial<TargetIntegrationConfig> | undefined): TargetIntegrationConfig;
+export declare function assertTargetIntegrationRuntimeBounds(runtime: TargetRuntimeKind, config: Partial<TargetIntegrationConfig> | undefined, label: string): TargetIntegrationConfig;
 export declare function targetConfigKeyForPlatform(target: PlatformConfigTarget): string;
 export declare function getTargetConfig(matrix: TargetConfigMatrix, target: PlatformConfigTarget | string): TargetConfig;
 export declare function isPlatformFeatureEnabled(config: TargetConfig, feature: PlatformFeature): boolean;

package/dist/runtime.js

@@ -12,6 +12,22 @@ export const targetIntegrations = [
     'inboundShare',
     'notifications',
 ];
+const integrationUpperBoundsByRuntime = {
+    'verse8-web': {
+        identityUpgrade: 'unsupported',
+        presentation: 'available',
+        sharing: 'unsupported',
+        inboundShare: 'unsupported',
+        notifications: 'unsupported',
+    },
+    'web-preview': {
+        identityUpgrade: 'disabled',
+        presentation: 'available',
+        sharing: 'available',
+        inboundShare: 'available',
+        notifications: 'unsupported',
+    },
+};
 const integrationAvailabilityStateValues = [
     'available',
     'disabled',
@@ -48,6 +64,31 @@ export function normalizeTargetIntegrationConfig(config) {
         presentationMode: normalizePresentationMode(config.presentationMode),
     };
 }
+export function assertTargetIntegrationRuntimeBounds(runtime, config, label) {
+    const integrations = normalizeTargetIntegrationConfig(config);
+    if (runtime !== 'verse8-web' && runtime !== 'web-preview') {
+        return integrations;
+    }
+    const upperBounds = integrationUpperBoundsByRuntime[runtime];
+    for (const integration of targetIntegrations) {
+        const state = integrations[integration];
+        const upperBound = upperBounds[integration];
+        if (!isIntegrationStateWithinUpperBound(state, upperBound)) {
+            throw new Error(`${label} cannot configure ${integration} as ${state} for ${runtime} runtime; maximum supported state is ${upperBound}.`);
+        }
+    }
+    return integrations;
+}
+function isIntegrationStateWithinUpperBound(state, upperBound) {
+    switch (upperBound) {
+        case 'available':
+            return true;
+        case 'disabled':
+            return state === 'disabled' || state === 'unsupported';
+        case 'unsupported':
+            return state === 'unsupported';
+    }
+}
 export function targetConfigKeyForPlatform(target) {
     return target === 'browser' ? 'web-preview' : target;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/target-config",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "Target-specific platform feature availability and effective config helpers for mpgd.",
   "license": "MIT",
   "repository": {
@@ -37,9 +37,9 @@
   ],
   "dependencies": {
     "typia": "13.0.2",
-    "@mpgd/catalog": "0.5.1",
-    "@mpgd/i18n": "0.5.4",
-    "@mpgd/platform": "0.8.0"
+    "@mpgd/catalog": "0.5.2",
+    "@mpgd/platform": "0.8.0",
+    "@mpgd/i18n": "0.5.4"
   },
   "devDependencies": {
     "ttsc": "0.18.4",