@mpgd/adapter-devvit 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 imjlk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+import { type BridgeRequest, type BridgeResponse } from '@mpgd/bridge';
+import type { PlatformGateway } from '@mpgd/platform';
+export declare const defaultDevvitBridgeEndpoint = "/api/mpgd/bridge";
+type BridgeErrorResponse = Extract<BridgeResponse, {
+  readonly ok: false;
+}>;
+export interface DevvitBridge {
+  request(input: BridgeRequest): Promise<BridgeResponse>;
+}
+export declare class DevvitBridgeError extends Error {
+  readonly code: string;
+  readonly requestId: string;
+  readonly retryable: boolean;
+  constructor(response: BridgeErrorResponse);
+}
+export interface DevvitPlatformGatewayOptions {
+  readonly appVersion: string;
+  readonly buildId: string;
+  readonly bridge?: DevvitBridge;
+  readonly fallbackBridge?: DevvitBridge;
+  readonly endpoint?: string;
+}
+export declare function createDevvitPlatformGateway(input: DevvitPlatformGatewayOptions): PlatformGateway;
+export declare function createDevvitFetchBridge(input?: {
+  readonly endpoint?: string | undefined;
+  readonly fetch?: typeof fetch | undefined;
+}): DevvitBridge;
+export declare function createDevvitSandboxBridge(): DevvitBridge;
+export {};

package/dist/index.js

@@ -0,0 +1,383 @@
+import { assertBridgeResponse, createBridgeError, } from '@mpgd/bridge';
+export const defaultDevvitBridgeEndpoint = '/api/mpgd/bridge';
+const devvitFallbackStoragePrefix = 'mpgd:devvit:fallback:';
+export class DevvitBridgeError extends Error {
+    code;
+    requestId;
+    retryable;
+    constructor(response) {
+        super(response.error.message);
+        this.name = 'DevvitBridgeError';
+        this.code = response.error.code;
+        this.requestId = response.id;
+        this.retryable = response.error.retryable;
+    }
+}
+export function createDevvitPlatformGateway(input) {
+    let lastResolvedStorageFallbackNamespace;
+    async function request(method, payload) {
+        const bridge = input.bridge ??
+            getBridge() ??
+            input.fallbackBridge ??
+            createDevvitFetchBridge({ endpoint: input.endpoint });
+        const response = await bridge.request({
+            id: generateRequestId(),
+            method,
+            payload,
+            meta: {
+                target: 'reddit',
+                appVersion: input.appVersion,
+                buildId: input.buildId,
+                sentAt: new Date().toISOString(),
+            },
+        });
+        if (!response.ok) {
+            throw new DevvitBridgeError(response);
+        }
+        return response.data;
+    }
+    return {
+        target: 'reddit',
+        getCapabilities: () => request('runtime.getCapabilities', {}),
+        identity: {
+            getPlayer: async () => {
+                const player = await request('identity.getPlayer', {});
+                rememberStorageFallbackNamespace(player);
+                return player;
+            },
+        },
+        commerce: {
+            getProducts: () => request('commerce.getProducts', {}),
+            purchase: (payload) => request('commerce.purchase', payload),
+            restore: () => request('commerce.restore', {}),
+            getEntitlements: () => request('commerce.getEntitlements', {}),
+        },
+        ads: {
+            preload: (payload) => request('ads.preload', payload),
+            showRewarded: (payload) => request('ads.showRewarded', payload),
+            showInterstitial: (payload) => request('ads.showInterstitial', payload),
+        },
+        leaderboard: {
+            submitScore: (payload) => request('leaderboard.submitScore', payload),
+            open: (payload) => request('leaderboard.open', payload ?? {}),
+        },
+        lifecycle: {
+            onPause() {
+                return () => { };
+            },
+            onResume() {
+                return () => { };
+            },
+        },
+        storage: {
+            async load(payload) {
+                let value;
+                try {
+                    value = await request('storage.load', payload);
+                }
+                catch (error) {
+                    const fallback = await loadStorageFallback(payload.key, {
+                        useCachedNamespaceOnFailure: true,
+                    });
+                    if (fallback !== null) {
+                        return fallback;
+                    }
+                    throw error;
+                }
+                const fallback = await loadStorageFallback(payload.key, {
+                    useCachedNamespaceOnFailure: value === null,
+                });
+                return fallback ?? (value === null ? null : { value });
+            },
+            async save(payload) {
+                let result;
+                try {
+                    result = await request('storage.save', payload);
+                }
+                catch (error) {
+                    if (await saveStorageFallback(payload, undefined, {
+                        useCachedNamespaceOnFailure: true,
+                    })) {
+                        return;
+                    }
+                    throw error;
+                }
+                if (result.saved !== true) {
+                    if (await saveStorageFallback(payload, result.playerId, {
+                        useCachedNamespaceOnFailure: false,
+                    })) {
+                        return;
+                    }
+                    throw new Error('Devvit storage save was not persisted and local fallback storage is unavailable.');
+                }
+                await removeStorageFallback(payload.key, result.playerId);
+            },
+        },
+    };
+    async function loadStorageFallback(key, options) {
+        if (!hasDevvitStorageFallbackCandidate(key, input.appVersion)) {
+            return null;
+        }
+        const namespace = await resolveNamespace(undefined, options);
+        return namespace === undefined ? null : loadDevvitStorageFallback(key, namespace);
+    }
+    async function saveStorageFallback(payload, playerId, options) {
+        const namespace = await resolveNamespace(playerId, options);
+        return namespace === undefined ? false : saveDevvitStorageFallback(payload, namespace);
+    }
+    async function removeStorageFallback(key, playerId) {
+        const namespace = await resolveNamespace(playerId, {
+            useCachedNamespaceOnFailure: true,
+        });
+        if (namespace === undefined) {
+            console.warn(`devvit storage fallback cleanup skipped due to unresolved namespace for key: ${key}`);
+        }
+        removeDevvitStorageFallback(key, namespace);
+    }
+    async function resolveNamespace(playerId, options) {
+        const namespace = storageFallbackNamespaceFromPlayerId(playerId);
+        if (namespace !== undefined) {
+            lastResolvedStorageFallbackNamespace = namespace;
+            return namespace;
+        }
+        try {
+            return await resolveStorageFallbackNamespace();
+        }
+        catch (error) {
+            console.warn(`devvit storage fallback namespace resolution failed: ${errorMessage(error)}`);
+            return options.useCachedNamespaceOnFailure ? lastResolvedStorageFallbackNamespace : undefined;
+        }
+    }
+    async function resolveStorageFallbackNamespace() {
+        const player = await request('identity.getPlayer', {});
+        return rememberStorageFallbackNamespace(player);
+    }
+    function rememberStorageFallbackNamespace(player) {
+        const playerId = player !== null && typeof player.playerId === 'string' && player.playerId.length > 0
+            ? player.playerId
+            : 'anonymous';
+        const namespace = devvitStorageFallbackNamespace(input.appVersion, playerId);
+        lastResolvedStorageFallbackNamespace = namespace;
+        return namespace;
+    }
+    function storageFallbackNamespaceFromPlayerId(playerId) {
+        return playerId !== undefined && playerId.length > 0
+            ? devvitStorageFallbackNamespace(input.appVersion, playerId)
+            : undefined;
+    }
+}
+export function createDevvitFetchBridge(input = {}) {
+    const endpoint = input.endpoint ?? defaultDevvitBridgeEndpoint;
+    return {
+        async request(bridgeRequest) {
+            const fetchImpl = input.fetch ?? globalThis.fetch;
+            if (typeof fetchImpl !== 'function') {
+                return createBridgeError(bridgeRequest.id, 'DEVVIT_FETCH_UNAVAILABLE', 'Devvit bridge fetch is not available.', false);
+            }
+            let response;
+            try {
+                response = await fetchImpl(endpoint, {
+                    method: 'POST',
+                    headers: {
+                        'content-type': 'application/json',
+                    },
+                    body: JSON.stringify(bridgeRequest),
+                });
+            }
+            catch (error) {
+                return createBridgeError(bridgeRequest.id, 'DEVVIT_BRIDGE_NETWORK_ERROR', `Devvit bridge network request failed: ${errorMessage(error)}`, true);
+            }
+            if (!response.ok) {
+                return createBridgeError(bridgeRequest.id, 'DEVVIT_BRIDGE_HTTP_ERROR', `Devvit bridge request failed with HTTP ${response.status}.`, response.status >= 500);
+            }
+            try {
+                const body = await response.json();
+                return assertBridgeResponse(body);
+            }
+            catch (error) {
+                return createBridgeError(bridgeRequest.id, 'DEVVIT_BRIDGE_PARSE_ERROR', `Devvit bridge response was not valid JSON: ${errorMessage(error)}`, false);
+            }
+        },
+    };
+}
+function getBridge() {
+    const globalBridgeHost = globalThis;
+    return globalBridgeHost.__DEVVIT_GAME_PLATFORM_BRIDGE__ ?? globalBridgeHost.__GAME_PLATFORM_BRIDGE__;
+}
+function generateRequestId() {
+    const cryptoImpl = globalThis.crypto;
+    if (typeof cryptoImpl?.randomUUID === 'function') {
+        return cryptoImpl.randomUUID();
+    }
+    if (typeof cryptoImpl?.getRandomValues === 'function') {
+        const values = new Uint32Array(2);
+        cryptoImpl.getRandomValues(values);
+        const first = values[0] ?? 0;
+        const second = values[1] ?? 0;
+        return `${Date.now().toString(36)}-${first.toString(36)}-${second.toString(36)}`;
+    }
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function createDevvitSandboxBridge() {
+    const storage = new Map();
+    return {
+        async request(input) {
+            switch (input.method) {
+                case 'runtime.getCapabilities':
+                    return ok(input, {
+                        nativeIap: false,
+                        nativeAds: false,
+                        rewardedAds: false,
+                        interstitialAds: false,
+                        nativeLeaderboard: true,
+                        achievements: false,
+                        cloudSave: true,
+                        socialShare: true,
+                        haptics: false,
+                        localizedContent: true,
+                    });
+                case 'identity.getPlayer':
+                    return ok(input, {
+                        playerId: 'reddit-sandbox-player',
+                        displayName: 'Reddit Sandbox Player',
+                    });
+                case 'commerce.getProducts':
+                case 'commerce.getEntitlements':
+                    return ok(input, []);
+                case 'commerce.purchase':
+                    return ok(input, {
+                        status: 'cancelled',
+                        entitlementIds: [],
+                    });
+                case 'commerce.restore':
+                    return ok(input, {
+                        restoredEntitlements: [],
+                    });
+                case 'ads.preload':
+                    return ok(input, {});
+                case 'leaderboard.open':
+                    return createBridgeError(input.id, 'DEVVIT_LEADERBOARD_OPEN_UNAVAILABLE', 'Devvit leaderboard display is not implemented yet.');
+                case 'ads.showRewarded':
+                    return ok(input, {
+                        status: 'unavailable',
+                        rewardGranted: false,
+                    });
+                case 'ads.showInterstitial':
+                    return ok(input, {
+                        status: 'unavailable',
+                    });
+                case 'leaderboard.submitScore':
+                    return ok(input, {
+                        submitted: true,
+                    });
+                case 'storage.load': {
+                    const payload = optionalObjectPayload(input.payload);
+                    const key = typeof payload.key === 'string' ? payload.key : undefined;
+                    return ok(input, key === undefined ? null : (storage.get(key) ?? null));
+                }
+                case 'storage.save': {
+                    const payload = optionalObjectPayload(input.payload);
+                    const key = typeof payload.key === 'string' ? payload.key : undefined;
+                    if (key !== undefined) {
+                        storage.set(key, payload.value);
+                    }
+                    return ok(input, {
+                        saved: key !== undefined,
+                    });
+                }
+                default:
+                    return createBridgeError(input.id, 'UNSUPPORTED_METHOD', `Unsupported Devvit sandbox method: ${input.method}`);
+            }
+        },
+    };
+}
+function optionalObjectPayload(payload) {
+    if (typeof payload !== 'object' || payload === null) {
+        return {};
+    }
+    return payload;
+}
+function ok(input, data) {
+    return {
+        id: input.id,
+        ok: true,
+        data,
+    };
+}
+function loadDevvitStorageFallback(key, namespace) {
+    const storage = browserLocalStorage();
+    if (storage === undefined) {
+        return null;
+    }
+    const fallbackKey = devvitStorageFallbackKey(key, namespace);
+    const stored = storage.getItem(fallbackKey);
+    if (stored === null) {
+        return null;
+    }
+    try {
+        return {
+            value: JSON.parse(stored),
+        };
+    }
+    catch {
+        storage.removeItem(fallbackKey);
+        return null;
+    }
+}
+function saveDevvitStorageFallback(input, namespace) {
+    const storage = browserLocalStorage();
+    if (storage === undefined) {
+        return false;
+    }
+    try {
+        storage.setItem(devvitStorageFallbackKey(input.key, namespace), JSON.stringify(input.value));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function removeDevvitStorageFallback(key, namespace) {
+    const storage = browserLocalStorage();
+    if (storage !== undefined) {
+        if (namespace !== undefined) {
+            storage.removeItem(devvitStorageFallbackKey(key, namespace));
+        }
+        storage.removeItem(legacyDevvitStorageFallbackKey(key));
+    }
+}
+function hasDevvitStorageFallbackCandidate(key, appVersion) {
+    const storage = browserLocalStorage();
+    if (storage === undefined) {
+        return false;
+    }
+    const prefix = `${devvitFallbackStoragePrefix}${encodeURIComponent(appVersion)}:`;
+    const suffix = `:${encodeURIComponent(key)}`;
+    for (let index = 0; index < storage.length; index += 1) {
+        const candidate = storage.key(index);
+        if (candidate?.startsWith(prefix) === true && candidate.endsWith(suffix)) {
+            return true;
+        }
+    }
+    return false;
+}
+function devvitStorageFallbackNamespace(appVersion, playerId) {
+    return `${encodeURIComponent(appVersion)}:${encodeURIComponent(playerId)}`;
+}
+function devvitStorageFallbackKey(key, namespace) {
+    return `${devvitFallbackStoragePrefix}${namespace}:${encodeURIComponent(key)}`;
+}
+function legacyDevvitStorageFallbackKey(key) {
+    return `${devvitFallbackStoragePrefix}${encodeURIComponent(key)}`;
+}
+function browserLocalStorage() {
+    try {
+        return globalThis.localStorage;
+    }
+    catch {
+        return undefined;
+    }
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@mpgd/adapter-devvit",
+  "version": "0.1.0",
+  "description": "Reddit Devvit Web platform adapter for mpgd games.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/imjlk/mpgd-kit.git",
+    "directory": "adapters/devvit"
+  },
+  "bugs": {
+    "url": "https://github.com/imjlk/mpgd-kit/issues"
+  },
+  "homepage": "https://github.com/imjlk/mpgd-kit#readme",
+  "keywords": [
+    "mpgd",
+    "phaser",
+    "vite",
+    "typescript",
+    "devvit",
+    "reddit",
+    "game-development",
+    "game-distribution"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@mpgd/bridge": "0.1.0",
+    "@mpgd/platform": "0.1.0"
+  },
+  "devDependencies": {
+    "ttsc": "0.16.9",
+    "typescript": "7.0.1-rc",
+    "vitest": "^4.0.0"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "check": "ttsc --noEmit",
+    "lint": "ttsc --noEmit",
+    "format": "ttsc format",
+    "fix": "ttsc fix",
+    "test": "vitest run"
+  }
+}