@makefully/adaptfully 2.1.0 → 3.0.1

package/lib/node/registrations.js

@@ -0,0 +1,314 @@
+import fs from 'node:fs';
+import { resolveRuntimeScript } from './paths.js';
+
+/** @typedef {Record<string, string>} RegistrationMap */
+
+/**
+ * @typedef {Object} StandardPlugin
+ * @property {string[]} scripts Runtime script paths relative to lib/runtime
+ * @property {(registerKey: string) => string} registration
+ * @property {string} [extScript] Optional HTML snippet injected before adaptfully scripts
+ */
+
+/** @type {Record<string, StandardPlugin>} */
+export const STANDARD_PLUGINS = {
+    'google-auth': {
+        scripts: ['core.js', 'platform.js', 'auth/_helpers.js', 'auth/google-auth.js'],
+        registration: (key) => `adaptfully.register('${key}', adaptfully.auth.Google);`,
+        extScript: '<script src="https://accounts.google.com/gsi/client" async defer></script>',
+    },
+    'steam-auth': {
+        scripts: ['core.js', 'platform.js', 'auth/_helpers.js', 'auth/steam-auth.js'],
+        registration: (key) => `adaptfully.register('${key}', adaptfully.auth.Steam);`,
+    },
+    'dev-auth': {
+        scripts: ['core.js', 'platform.js', 'auth/_helpers.js', 'auth/dev-auth.js'],
+        registration: (key) => `adaptfully.register('${key}', adaptfully.auth.Dev);`,
+    },
+};
+
+/** Default Wrapfully builder → config.platforms key */
+export const DEFAULT_BUILDER_PLATFORMS = {
+    steam: 'steam',
+    'steam-dev': 'steam',
+    win: 'steam',
+    'win-dev': 'steam',
+    mac: 'steam',
+    'mac-dev': 'steam',
+    linux: 'steam',
+    'linux-dev': 'steam',
+    android: 'android',
+    'android-dev': 'android',
+    ios: 'ios',
+    'ios-dev': 'ios',
+    'ios-sim': 'ios',
+    webapp: 'web',
+    cordova: 'cordova',
+    'cordova-dev': 'cordova',
+    apple: 'apple',
+    'apple-dev': 'apple',
+    uwp: 'uwp',
+};
+
+const ADAPTFULLY_MARKER = '<!-- adaptfully -->';
+const ADAPTFULLY_END_MARKER = '<!-- /adaptfully -->';
+
+function readRuntimeScript(relativePath) {
+    return fs.readFileSync(resolveRuntimeScript(relativePath), 'utf8');
+}
+
+/**
+ * @param {RegistrationMap} registrations
+ * @returns {{
+ *   runtimeScripts: string[],
+ *   extScripts: string[],
+ *   deployScripts: string[],
+ *   inlineRegistrations: string[],
+ * }}
+ */
+export function collectRegistrationParts(registrations) {
+    if (!registrations || typeof registrations !== 'object') {
+        throw new Error('registrations must be an object');
+    }
+
+    const entries = Object.entries(registrations);
+    const runtimeScripts = [];
+    const extScripts = [];
+    const deployScripts = [];
+    const inlineRegistrations = [];
+
+    for (const [registerKey, value] of entries) {
+        if (!value || typeof value !== 'string') {
+            throw new Error(`Invalid registration for "${registerKey}": expected a string`);
+        }
+
+        if (isDeployPath(value)) {
+            const src = value.startsWith('/') ? value : `/${value.replace(/^\.\//, '')}`;
+            deployScripts.push({ key: registerKey, src });
+            continue;
+        }
+
+        const plugin = STANDARD_PLUGINS[value];
+        if (!plugin) {
+            throw new Error(
+                `Unknown Adaptfully plugin "${value}" for "${registerKey}". `
+                + `Known plugins: ${Object.keys(STANDARD_PLUGINS).join(', ')}`,
+            );
+        }
+
+        for (const script of plugin.scripts) {
+            if (!runtimeScripts.includes(script)) {
+                runtimeScripts.push(script);
+            }
+        }
+
+        if (plugin.extScript && !extScripts.includes(plugin.extScript)) {
+            extScripts.push(plugin.extScript);
+        }
+
+        inlineRegistrations.push(plugin.registration(registerKey));
+    }
+
+    return { runtimeScripts, extScripts, deployScripts, inlineRegistrations };
+}
+
+/**
+ * @param {RegistrationMap} registrations
+ */
+export function resolveRegistrationAssets(registrations) {
+    const { runtimeScripts, extScripts, deployScripts, inlineRegistrations } = collectRegistrationParts(registrations);
+
+    return {
+        runtimeScriptPaths: runtimeScripts.map((rel) => resolveRuntimeScript(rel)),
+        inlineScript: inlineRegistrations.join('\n'),
+        extScripts,
+        deployScriptSrcs: deployScripts.map(({ src }) => src),
+    };
+}
+
+function isDeployPath(value) {
+    return value.startsWith('/') || value.startsWith('./') || value.includes('/');
+}
+
+/**
+ * @param {string} builder
+ * @param {Record<string, { builders?: string[], registrations?: RegistrationMap }>} [platforms]
+ * @returns {string | null}
+ */
+export function resolvePlatformKey(builder, platforms = {}) {
+    if (!platforms || Object.keys(platforms).length === 0) {
+        return null;
+    }
+
+    for (const [platformKey, platformConfig] of Object.entries(platforms)) {
+        if (platformConfig?.builders?.includes(builder)) {
+            return platformKey;
+        }
+    }
+
+    if (platforms[builder]?.registrations) {
+        return builder;
+    }
+
+    const mapped = DEFAULT_BUILDER_PLATFORMS[builder];
+    if (mapped && platforms[mapped]) {
+        return mapped;
+    }
+
+    if (platforms[builder]) {
+        return builder;
+    }
+
+    return mapped ?? null;
+}
+
+/**
+ * @param {RegistrationMap} registrations
+ * @param {{ log?: (message: string) => void }} [options]
+ */
+export function buildAdaptfullyInjection(registrations, options = {}) {
+    const log = options.log ?? (() => {});
+    const parts = collectRegistrationParts(registrations);
+    if (parts.runtimeScripts.length === 0
+        && parts.extScripts.length === 0
+        && parts.deployScripts.length === 0
+        && parts.inlineRegistrations.length === 0) {
+        return '';
+    }
+
+    for (const [registerKey, value] of Object.entries(registrations)) {
+        if (isDeployPath(value)) {
+            const src = value.startsWith('/') ? value : `/${value.replace(/^\.\//, '')}`;
+            log(`adaptfully: registering ${registerKey} ← ${src}`);
+        } else {
+            log(`adaptfully: registering ${registerKey} ← ${value}`);
+        }
+    }
+
+    let block = `${ADAPTFULLY_MARKER}\n`;
+
+    for (const extScript of parts.extScripts) {
+        block += `${extScript}\n`;
+    }
+
+    for (const script of parts.runtimeScripts) {
+        block += `<script>\n${readRuntimeScript(script)}\n</script>\n`;
+    }
+
+    for (const { src } of parts.deployScripts) {
+        block += `<script src="${src}"></script>\n`;
+    }
+
+    if (parts.inlineRegistrations.length > 0) {
+        block += `<script>\n${parts.inlineRegistrations.join('\n')}\n</script>\n`;
+    }
+
+    block += `${ADAPTFULLY_END_MARKER}\n`;
+    return block;
+}
+
+/**
+ * @param {string} html
+ * @param {string} injection
+ */
+export function injectAdaptfullyRegistrations(html, injection) {
+    if (!injection) {
+        return html;
+    }
+
+    const markerPattern = new RegExp(
+        `${escapeRegExp(ADAPTFULLY_MARKER)}[\\s\\S]*?${escapeRegExp(ADAPTFULLY_END_MARKER)}\\n?`,
+    );
+
+    if (markerPattern.test(html)) {
+        return html.replace(markerPattern, injection);
+    }
+
+    if (html.includes('<!-- scripts -->')) {
+        return html.replace('<!-- scripts -->', `${injection}<!-- scripts -->`);
+    }
+
+    if (html.includes('</head>')) {
+        return html.replace('</head>', `${injection}</head>`);
+    }
+
+    throw new Error(
+        'Cannot inject Adaptfully registrations: HTML needs '
+        + '<!-- adaptfully -->…<!-- /adaptfully -->, <!-- scripts -->, or </head>',
+    );
+}
+
+/**
+ * @param {string} platformKey
+ * @param {{ config?: { platforms?: Record<string, { registrations?: RegistrationMap, builder?: string }> } }} pkg
+ * @returns {{ platformKey: string, registrations: RegistrationMap | null }}
+ */
+export function resolvePlatformRegistrationsByKey(platformKey, pkg) {
+    const platforms = pkg.config?.platforms ?? {};
+    const registrations = platforms[platformKey]?.registrations ?? null;
+
+    if (!registrations || Object.keys(registrations).length === 0) {
+        return { platformKey, registrations: null };
+    }
+
+    return { platformKey, registrations };
+}
+
+/**
+ * @param {string} platformKey
+ * @param {{ config?: { platforms?: Record<string, { registrations?: RegistrationMap, builder?: string }> } }} pkg
+ * @param {{ log?: (message: string) => void }} [options]
+ * @returns {string}
+ */
+export function adaptfullyInjectionForPlatform(platformKey, pkg, options = {}) {
+    const log = options.log ?? (() => {});
+    const { registrations } = resolvePlatformRegistrationsByKey(platformKey, pkg);
+
+    if (!registrations) {
+        log(`adaptfully: no registrations configured for platform "${platformKey}"; skipping injection`);
+        return '';
+    }
+
+    return buildAdaptfullyInjection(registrations, { log });
+}
+
+/**
+ * @param {string} platformKey
+ * @param {{ config?: { platforms?: Record<string, { builder?: string }> } }} pkg
+ */
+export function resolveBuilderForPlatform(platformKey, pkg) {
+    const platform = pkg.config?.platforms?.[platformKey];
+    if (platform?.builder) {
+        return platform.builder;
+    }
+
+    if (platformKey === 'web') {
+        return 'webapp';
+    }
+
+    return platformKey;
+}
+
+/**
+ * @param {string} arg CLI platform or Wrapfully builder name
+ * @param {{ config?: { platforms?: Record<string, { builder?: string }> } }} pkg
+ */
+export function resolveCliPlatformAndBuilder(arg, pkg) {
+    const platforms = pkg.config?.platforms ?? {};
+
+    if (platforms[arg]) {
+        return {
+            platformKey: arg,
+            builder: resolveBuilderForPlatform(arg, pkg),
+        };
+    }
+
+    return {
+        platformKey: resolvePlatformKey(arg, platforms) ?? arg,
+        builder: arg,
+    };
+}
+
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/lib/node/report.js

@@ -1,42 +1,42 @@
-import fs from 'node:fs';
-
-/**
- * @param {string} builder
- * @param {{ name: string, version: string }} pkg
- */
-export function printBuildReport(builder, pkg) {
-    const statusPath = './output/wrapfully-status.json';
-    const legacyPath = `./output/${pkg.name}-${pkg.version}-${builder}.txt`;
-
-    let status = null;
-    if (fs.existsSync(statusPath)) {
-        try {
-            status = JSON.parse(fs.readFileSync(statusPath, 'utf8'));
-        } catch {
-            console.warn('Unable to read wrapfully-status.json');
-        }
-    }
-
-    if (status) {
-        for (const event of status.events) {
-            const line = `[${event.step}] ${event.message}`;
-            if (event.level === 'error') {
-                console.error(line);
-            } else if (event.level === 'warn') {
-                console.warn(line);
-            } else {
-                console.log(line);
-            }
-        }
-
-        if (!status.ok) {
-            console.error('Wrapfully build finished with errors.');
-            process.exit(1);
-        }
-        return;
-    }
-
-    if (fs.existsSync(legacyPath)) {
-        console.log(fs.readFileSync(legacyPath, 'utf8'));
-    }
-}
+import fs from 'node:fs';
+
+/**
+ * @param {string} builder
+ * @param {{ name: string, version: string }} pkg
+ */
+export function printBuildReport(builder, pkg) {
+    const statusPath = './output/wrapfully-status.json';
+    const legacyPath = `./output/${pkg.name}-${pkg.version}-${builder}.txt`;
+
+    let status = null;
+    if (fs.existsSync(statusPath)) {
+        try {
+            status = JSON.parse(fs.readFileSync(statusPath, 'utf8'));
+        } catch {
+            console.warn('Unable to read wrapfully-status.json');
+        }
+    }
+
+    if (status) {
+        for (const event of status.events) {
+            const line = `[${event.step}] ${event.message}`;
+            if (event.level === 'error') {
+                console.error(line);
+            } else if (event.level === 'warn') {
+                console.warn(line);
+            } else {
+                console.log(line);
+            }
+        }
+
+        if (!status.ok) {
+            console.error('Wrapfully build finished with errors.');
+            process.exit(1);
+        }
+        return;
+    }
+
+    if (fs.existsSync(legacyPath)) {
+        console.log(fs.readFileSync(legacyPath, 'utf8'));
+    }
+}

package/lib/runtime/auth/_helpers.js

@@ -1,38 +1,38 @@
-/* global window */
-
-/**
- * @typedef {{ id: string, email: string }} AuthUser
- * @typedef {(result: { authenticated: boolean, user?: AuthUser | null }) => void} AuthCallback
- * @typedef {(err?: { error?: string }) => void} ReadyCallback
- *
- * @typedef {Object} AuthPlugin
- * @property {string} name
- * @property {(done: ReadyCallback) => void} whenReady
- * @property {(callback: AuthCallback) => void} login
- * @property {(callback: AuthCallback) => void} silentLogin
- * @property {(callback: () => void) => void} logout
- * @property {() => AuthUser | null} getUser
- * @property {() => boolean} isAuthenticated
- */
-
-(function registerAuthHelpers(ns) {
-    const helpers = {
-        configValue(key, fallback) {
-            if (!ns.has('config')) {
-                return fallback;
-            }
-            const config = ns.get('config');
-            if (config && config[key] != null) {
-                return config[key];
-            }
-            return fallback;
-        },
-
-        getStorage() {
-            return ns.has('storage') ? ns.get('storage') : null;
-        },
-    };
-
-    ns.auth = ns.auth || {};
-    ns.auth.helpers = helpers;
-}(window.adaptfully));
+/* global window */
+
+/**
+ * @typedef {{ id: string, email: string }} AuthUser
+ * @typedef {(result: { authenticated: boolean, user?: AuthUser | null }) => void} AuthCallback
+ * @typedef {(err?: { error?: string }) => void} ReadyCallback
+ *
+ * @typedef {Object} AuthPlugin
+ * @property {string} name
+ * @property {(done: ReadyCallback) => void} whenReady
+ * @property {(callback: AuthCallback) => void} login
+ * @property {(callback: AuthCallback) => void} silentLogin
+ * @property {(callback: () => void) => void} logout
+ * @property {() => AuthUser | null} getUser
+ * @property {() => boolean} isAuthenticated
+ */
+
+(function registerAuthHelpers(ns) {
+    const helpers = {
+        configValue(key, fallback) {
+            if (!ns.has('config')) {
+                return fallback;
+            }
+            const config = ns.get('config');
+            if (config && config[key] != null) {
+                return config[key];
+            }
+            return fallback;
+        },
+
+        getStorage() {
+            return ns.has('storage') ? ns.get('storage') : null;
+        },
+    };
+
+    ns.auth = ns.auth || {};
+    ns.auth.helpers = helpers;
+}(window.adaptfully));

package/lib/runtime/auth/dev-auth.js

@@ -1,78 +1,78 @@
-/* global fetch, window */
-
-/**
- * Local development auth — test values for dev builds outside the Wrapfully flow.
- *
- *   adaptfully.register('auth', adaptfully.auth.Dev);
- */
-(function registerDevAuth(ns) {
-    const { getStorage } = ns.auth.helpers;
-
-    const apiBase = () => {
-        if (ns.has('config')) {
-            const config = ns.get('config');
-            if (config && typeof config.apiBase === 'string') {
-                return config.apiBase;
-            }
-        }
-        if (typeof window.__ADAPTFULLY_API__ === 'string') {
-            return window.__ADAPTFULLY_API__;
-        }
-        return '';
-    };
-
-    const apiGet = (path) => fetch(`${apiBase()}${path}`, { credentials: 'include' })
-        .then((response) => response.json());
-
-    class DevAuthPlugin {
-        constructor() {
-            this.user = { id: 'dev-local-user', email: 'dev@local' };
-            this.authenticated = true;
-        }
-
-        whenReady(done) {
-            done();
-        }
-
-        login(callback) {
-            apiGet('/get-user')
-                .then((user) => {
-                    if (user?.id) {
-                        this.user = { id: user.id, email: user.email || 'dev@local' };
-                        this.authenticated = true;
-                    }
-                    callback({ authenticated: this.authenticated, user: this.getUser() });
-                })
-                .catch(() => {
-                    this.user = { id: 'dev-local-user', email: 'dev@local' };
-                    this.authenticated = true;
-                    callback({ authenticated: true, user: this.getUser() });
-                });
-        }
-
-        silentLogin(callback) {
-            callback({ authenticated: this.authenticated, user: this.getUser() });
-        }
-
-        logout(callback) {
-            const storage = getStorage();
-            this.authenticated = false;
-            this.user = null;
-            storage?.remove('lastLoggedIn');
-            callback();
-        }
-
-        getUser() {
-            if (!this.authenticated || !this.user) {
-                return null;
-            }
-            return { id: this.user.id, email: this.user.email };
-        }
-
-        isAuthenticated() {
-            return !!this.authenticated;
-        }
-    }
-
-    ns.auth.Dev = () => new DevAuthPlugin();
-}(window.adaptfully));
+/* global fetch, window */
+
+/**
+ * Local development auth — test values for dev builds outside the Wrapfully flow.
+ *
+ *   adaptfully.register('auth', adaptfully.auth.Dev);
+ */
+(function registerDevAuth(ns) {
+    const { getStorage } = ns.auth.helpers;
+
+    const apiBase = () => {
+        if (ns.has('config')) {
+            const config = ns.get('config');
+            if (config && typeof config.apiBase === 'string') {
+                return config.apiBase;
+            }
+        }
+        if (typeof window.__ADAPTFULLY_API__ === 'string') {
+            return window.__ADAPTFULLY_API__;
+        }
+        return '';
+    };
+
+    const apiGet = (path) => fetch(`${apiBase()}${path}`, { credentials: 'include' })
+        .then((response) => response.json());
+
+    class DevAuthPlugin {
+        constructor() {
+            this.user = { id: 'dev-local-user', email: 'dev@local' };
+            this.authenticated = true;
+        }
+
+        whenReady(done) {
+            done();
+        }
+
+        login(callback) {
+            apiGet('/get-user')
+                .then((user) => {
+                    if (user?.id) {
+                        this.user = { id: user.id, email: user.email || 'dev@local' };
+                        this.authenticated = true;
+                    }
+                    callback({ authenticated: this.authenticated, user: this.getUser() });
+                })
+                .catch(() => {
+                    this.user = { id: 'dev-local-user', email: 'dev@local' };
+                    this.authenticated = true;
+                    callback({ authenticated: true, user: this.getUser() });
+                });
+        }
+
+        silentLogin(callback) {
+            callback({ authenticated: this.authenticated, user: this.getUser() });
+        }
+
+        logout(callback) {
+            const storage = getStorage();
+            this.authenticated = false;
+            this.user = null;
+            storage?.remove('lastLoggedIn');
+            callback();
+        }
+
+        getUser() {
+            if (!this.authenticated || !this.user) {
+                return null;
+            }
+            return { id: this.user.id, email: this.user.email };
+        }
+
+        isAuthenticated() {
+            return !!this.authenticated;
+        }
+    }
+
+    ns.auth.Dev = () => new DevAuthPlugin();
+}(window.adaptfully));