@gamedevland/vite 0.0.1

package/LICENSE

@@ -0,0 +1,23 @@
+Gamedev Land SDK License
+
+Copyright (c) 2026 Gamedev Land
+
+This license applies to the compiled @gamedevland/vite npm package and its TypeScript declaration files.
+
+Permission is granted to install and use the package to build, test, and distribute games, demos,
+tutorials, and related web applications.
+
+The package may be redistributed only as an unmodified dependency through package managers, deployment
+artifacts, or application bundles generated as part of a game or web application.
+
+You may not:
+
+- claim that the SDK itself is open source;
+- republish, sublicense, sell, or repackage the SDK as a competing SDK, engine, library, or framework;
+- remove copyright, license, or package identity notices;
+- use the package name, author name, or repository identity to imply endorsement without permission.
+
+The SDK 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 arising from
+the SDK or its use.

package/README.md

@@ -0,0 +1,30 @@
+# @gamedevland/vite
+
+Vite build tooling for HTML5 games built with `@gamedevland/engine`.
+
+## Install
+
+```bash
+npm install @gamedevland/engine @gamedevland/vite
+```
+
+Vite 7 or 8 must be installed in the game project.
+
+## Usage
+
+```ts
+import { createGameViteConfig } from '@gamedevland/vite';
+
+export default ({ mode }: { readonly mode: string }) =>
+  createGameViteConfig({
+    mode,
+    repoRoot: __dirname,
+  });
+```
+
+The package provides the shared Gamedev Land platform configuration, development proxy setup,
+environment resolution, and platform SDK injection used by engine-based game projects.
+
+## License
+
+This package is public but not open source. See [LICENSE](./LICENSE).

package/dist/BuildDefaultLocaleEnvResolver.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Resolves and validates the build-time default locale.
+ */
+export declare class BuildDefaultLocaleEnvResolver {
+    static resolve(mode: string, cwd: string): string;
+}

package/dist/BuildDefaultLocaleEnvResolver.js

@@ -0,0 +1,19 @@
+import { LocaleCatalog } from '@gamedevland/engine/configs';
+import { loadEnv } from 'vite';
+/**
+ * Resolves and validates the build-time default locale.
+ */
+export class BuildDefaultLocaleEnvResolver {
+    static resolve(mode, cwd) {
+        const env = loadEnv(mode, cwd, '');
+        const rawLocale = process.env.VITE_DEFAULT_LOCALE ?? env.VITE_DEFAULT_LOCALE;
+        if (rawLocale == null || rawLocale.length === 0) {
+            return LocaleCatalog.DEFAULT;
+        }
+        const normalized = LocaleCatalog.normalize(rawLocale);
+        if (normalized === null) {
+            throw new Error(`[vite] Unsupported VITE_DEFAULT_LOCALE value "${rawLocale}". Supported values: ${LocaleCatalog.getSupportedList().join(', ')}.`);
+        }
+        return normalized;
+    }
+}

package/dist/BuildGameDistributionGameIdConfigResolver.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Resolves the GameDistribution game id from the static game JSON config.
+ */
+export declare class BuildGameDistributionGameIdConfigResolver {
+    private static readonly CONFIG_FILE_PATH;
+    private static readonly ROOT_PATH;
+    private static readonly GAMEDISTRIBUTION_PATH;
+    private static readonly GAME_ID_PATH;
+    static resolve(platformId: string, repoRoot: string): string | undefined;
+    private static decodeConfig;
+    private static isRecord;
+}

package/dist/BuildGameDistributionGameIdConfigResolver.js

@@ -0,0 +1,58 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { PlatformCatalog, PlatformIntegrationsConfigContract } from '@gamedevland/engine/platforms';
+/**
+ * Resolves the GameDistribution game id from the static game JSON config.
+ */
+export class BuildGameDistributionGameIdConfigResolver {
+    static CONFIG_FILE_PATH = 'game/assets/json/configs/common/app/platforms.json';
+    static ROOT_PATH = '$';
+    static GAMEDISTRIBUTION_PATH = '$.gamedistribution';
+    static GAME_ID_PATH = '$.gamedistribution.gameId';
+    static resolve(platformId, repoRoot) {
+        if (platformId !== PlatformCatalog.GAMEDISTRIBUTION) {
+            return undefined;
+        }
+        const filePath = path.resolve(repoRoot, BuildGameDistributionGameIdConfigResolver.CONFIG_FILE_PATH);
+        let rawContent = '';
+        try {
+            rawContent = fs.readFileSync(filePath, 'utf-8');
+        }
+        catch (cause) {
+            throw new Error(`[vite] Failed to read GameDistribution config at '${filePath}'.`, { cause });
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(rawContent);
+        }
+        catch (cause) {
+            throw new Error(`[vite] Invalid JSON in GameDistribution config '${filePath}'.`, { cause });
+        }
+        const decoded = BuildGameDistributionGameIdConfigResolver.decodeConfig(parsed, filePath);
+        return PlatformIntegrationsConfigContract.getRequiredGameDistributionGameId(decoded, filePath);
+    }
+    static decodeConfig(input, filePath) {
+        if (!BuildGameDistributionGameIdConfigResolver.isRecord(input)) {
+            throw new Error(`[vite] ${filePath} expected object at '${BuildGameDistributionGameIdConfigResolver.ROOT_PATH}'`);
+        }
+        const rawGameDistribution = input.gamedistribution;
+        if (rawGameDistribution === undefined) {
+            return {};
+        }
+        if (!BuildGameDistributionGameIdConfigResolver.isRecord(rawGameDistribution)) {
+            throw new Error(`[vite] ${filePath} expected object at '${BuildGameDistributionGameIdConfigResolver.GAMEDISTRIBUTION_PATH}'`);
+        }
+        const rawGameId = rawGameDistribution.gameId;
+        if (typeof rawGameId !== 'string' || rawGameId.trim().length === 0) {
+            throw new Error(`[vite] ${filePath} expected non-empty string at '${BuildGameDistributionGameIdConfigResolver.GAME_ID_PATH}'`);
+        }
+        return {
+            gamedistribution: {
+                gameId: rawGameId.trim(),
+            },
+        };
+    }
+    static isRecord(value) {
+        return typeof value === 'object' && value !== null && !Array.isArray(value);
+    }
+}

package/dist/BuildGameDistributionSdkHeadTagCatalog.d.ts

@@ -0,0 +1,9 @@
+import type { HtmlTagDescriptor } from 'vite';
+/**
+ * Produces build-time HTML head tags required by the GameDistribution SDK.
+ */
+export declare class BuildGameDistributionSdkHeadTagCatalog {
+    static resolve(gameId: string | undefined): HtmlTagDescriptor[];
+    private static createScriptTag;
+    private static createInlineScriptTag;
+}

package/dist/BuildGameDistributionSdkHeadTagCatalog.js

@@ -0,0 +1,29 @@
+import { GameDistributionBootstrapContract } from '@gamedevland/engine/platforms';
+/**
+ * Produces build-time HTML head tags required by the GameDistribution SDK.
+ */
+export class BuildGameDistributionSdkHeadTagCatalog {
+    static resolve(gameId) {
+        if (!gameId) {
+            throw new Error('[vite] Missing GameDistribution game id while preparing SDK head tags.');
+        }
+        return [
+            BuildGameDistributionSdkHeadTagCatalog.createInlineScriptTag(GameDistributionBootstrapContract.createBootstrapScript(gameId)),
+            BuildGameDistributionSdkHeadTagCatalog.createScriptTag(GameDistributionBootstrapContract.SDK_SCRIPT_SRC, { id: GameDistributionBootstrapContract.SDK_SCRIPT_ID }),
+        ];
+    }
+    static createScriptTag(src, attrs) {
+        return {
+            tag: 'script',
+            attrs: { src, ...(attrs ?? {}) },
+            injectTo: 'head-prepend',
+        };
+    }
+    static createInlineScriptTag(children) {
+        return {
+            tag: 'script',
+            children,
+            injectTo: 'head-prepend',
+        };
+    }
+}

package/dist/BuildPlatformDevProxyCatalog.d.ts

@@ -0,0 +1,8 @@
+import type { ProxyOptions } from 'vite';
+/**
+ * Build-time mapping for platform-specific dev proxy configuration.
+ */
+export declare class BuildPlatformDevProxyCatalog {
+    private static readonly DEV_PROXY_BY_PLATFORM;
+    static resolve(platformId: string): Readonly<Record<string, string | ProxyOptions>> | undefined;
+}

package/dist/BuildPlatformDevProxyCatalog.js

@@ -0,0 +1,17 @@
+import { PlatformCatalog } from '@gamedevland/engine/platforms';
+/**
+ * Build-time mapping for platform-specific dev proxy configuration.
+ */
+export class BuildPlatformDevProxyCatalog {
+    static DEV_PROXY_BY_PLATFORM = {
+        [PlatformCatalog.YANDEX]: {
+            '/sdk.js': {
+                target: 'https://sdk.games.s3.yandex.net',
+                changeOrigin: true,
+            },
+        },
+    };
+    static resolve(platformId) {
+        return BuildPlatformDevProxyCatalog.DEV_PROXY_BY_PLATFORM[platformId];
+    }
+}

package/dist/BuildPlatformEnvResolver.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Resolves and validates build platform from environment.
+ */
+export declare class BuildPlatformEnvResolver {
+    static resolve(mode: string, cwd: string): string;
+}

package/dist/BuildPlatformEnvResolver.js

@@ -0,0 +1,18 @@
+import { loadEnv } from 'vite';
+import { PlatformCatalog } from '@gamedevland/engine/platforms';
+/**
+ * Resolves and validates build platform from environment.
+ */
+export class BuildPlatformEnvResolver {
+    static resolve(mode, cwd) {
+        const env = loadEnv(mode, cwd, '');
+        const rawPlatformId = process.env.VITE_PLATFORM ?? env.VITE_PLATFORM;
+        if (rawPlatformId == null || rawPlatformId.length === 0) {
+            return PlatformCatalog.getDefault();
+        }
+        if (!PlatformCatalog.isSupported(rawPlatformId)) {
+            throw new Error(`[vite] Unsupported VITE_PLATFORM value "${rawPlatformId}". Supported values: ${PlatformCatalog.getSupportedList().join(', ')}.`);
+        }
+        return rawPlatformId;
+    }
+}

package/dist/BuildPlatformSdkCatalog.d.ts

@@ -0,0 +1,13 @@
+import type { HtmlTagDescriptor } from 'vite';
+interface BuildPlatformSdkCatalogOptions {
+    readonly gameDistributionGameId?: string;
+}
+/**
+ * Build-time mapping for platform SDK head tag injection.
+ */
+export declare class BuildPlatformSdkCatalog {
+    private static readonly HEAD_TAG_RESOLVER_BY_PLATFORM;
+    static resolveHeadTags(platformId: string, options?: BuildPlatformSdkCatalogOptions): HtmlTagDescriptor[];
+    private static createScriptTag;
+}
+export {};

package/dist/BuildPlatformSdkCatalog.js

@@ -0,0 +1,28 @@
+import { PlatformCatalog } from '@gamedevland/engine/platforms';
+import { BuildGameDistributionSdkHeadTagCatalog } from './BuildGameDistributionSdkHeadTagCatalog.js';
+/**
+ * Build-time mapping for platform SDK head tag injection.
+ */
+export class BuildPlatformSdkCatalog {
+    static HEAD_TAG_RESOLVER_BY_PLATFORM = {
+        [PlatformCatalog.POKI]: () => [
+            BuildPlatformSdkCatalog.createScriptTag('https://game-cdn.poki.com/scripts/v2/poki-sdk.js'),
+        ],
+        [PlatformCatalog.CRAZYGAMES]: () => [
+            BuildPlatformSdkCatalog.createScriptTag('https://sdk.crazygames.com/crazygames-sdk-v3.js'),
+        ],
+        [PlatformCatalog.YANDEX]: () => [BuildPlatformSdkCatalog.createScriptTag('/sdk.js')],
+        [PlatformCatalog.GAMEDISTRIBUTION]: (options) => BuildGameDistributionSdkHeadTagCatalog.resolve(options?.gameDistributionGameId),
+    };
+    static resolveHeadTags(platformId, options) {
+        const resolver = BuildPlatformSdkCatalog.HEAD_TAG_RESOLVER_BY_PLATFORM[platformId];
+        return resolver ? resolver(options) : [];
+    }
+    static createScriptTag(src, attrs) {
+        return {
+            tag: 'script',
+            attrs: { src, ...(attrs ?? {}) },
+            injectTo: 'head-prepend',
+        };
+    }
+}

package/dist/BuildPlatformSdkInjectPluginFactory.d.ts

@@ -0,0 +1,9 @@
+import type { Plugin } from 'vite';
+/**
+ * Produces HTML transform plugin that injects platform SDK script tag.
+ */
+export declare class BuildPlatformSdkInjectPluginFactory {
+    static create(platformId: string, options?: {
+        readonly gameDistributionGameId?: string;
+    }): Plugin;
+}

package/dist/BuildPlatformSdkInjectPluginFactory.js

@@ -0,0 +1,18 @@
+import { BuildPlatformSdkCatalog } from './BuildPlatformSdkCatalog.js';
+/**
+ * Produces HTML transform plugin that injects platform SDK script tag.
+ */
+export class BuildPlatformSdkInjectPluginFactory {
+    static create(platformId, options) {
+        return {
+            name: 'platform-sdk-inject',
+            transformIndexHtml() {
+                const headTags = BuildPlatformSdkCatalog.resolveHeadTags(platformId, options);
+                if (headTags.length === 0) {
+                    return;
+                }
+                return headTags;
+            },
+        };
+    }
+}

package/dist/GameViteConfigFactory.d.ts

@@ -0,0 +1,11 @@
+import type { UserConfig } from 'vite';
+export interface GameViteConfigFactoryOptions {
+    readonly mode: string;
+    readonly repoRoot: string;
+}
+/**
+ * Composition root for game Vite configuration.
+ */
+export declare class GameViteConfigFactory {
+    static create(options: GameViteConfigFactoryOptions): UserConfig;
+}

package/dist/GameViteConfigFactory.js

@@ -0,0 +1,56 @@
+import path from 'node:path';
+import { BuildDefaultLocaleEnvResolver } from './BuildDefaultLocaleEnvResolver.js';
+import { BuildGameDistributionGameIdConfigResolver } from './BuildGameDistributionGameIdConfigResolver.js';
+import { BuildPlatformDevProxyCatalog } from './BuildPlatformDevProxyCatalog.js';
+import { BuildPlatformEnvResolver } from './BuildPlatformEnvResolver.js';
+import { BuildPlatformSdkInjectPluginFactory } from './BuildPlatformSdkInjectPluginFactory.js';
+/**
+ * Composition root for game Vite configuration.
+ */
+export class GameViteConfigFactory {
+    static create(options) {
+        const platformId = BuildPlatformEnvResolver.resolve(options.mode, process.cwd());
+        const defaultLocale = BuildDefaultLocaleEnvResolver.resolve(options.mode, process.cwd());
+        const gameDistributionGameId = BuildGameDistributionGameIdConfigResolver.resolve(platformId, options.repoRoot);
+        const platformSdkInjectOptions = gameDistributionGameId === undefined ? undefined : { gameDistributionGameId };
+        const devProxy = BuildPlatformDevProxyCatalog.resolve(platformId);
+        return {
+            root: path.resolve(options.repoRoot, 'game'),
+            // Keep built asset URLs relative so dist/index.html works from subpaths
+            // (e.g. Live Server at /dist/) and static hosts without root rewrites.
+            base: './',
+            resolve: {
+                alias: [
+                    { find: '@game', replacement: path.resolve(options.repoRoot, 'game') },
+                    { find: '@json', replacement: path.resolve(options.repoRoot, 'game/json') },
+                    { find: '@common', replacement: path.resolve(options.repoRoot, 'game/src/common') },
+                    { find: '@modules', replacement: path.resolve(options.repoRoot, 'modules') },
+                ],
+            },
+            server: {
+                port: 5173,
+                open: true,
+                ...(devProxy ? { proxy: devProxy } : {}),
+            },
+            preview: {
+                port: 5173,
+            },
+            define: {
+                'import.meta.env.VITE_PLATFORM': JSON.stringify(platformId),
+                'import.meta.env.VITE_DEFAULT_LOCALE': JSON.stringify(defaultLocale),
+            },
+            esbuild: {
+                // DI/FSM tokens currently rely on runtime class.name values.
+                // Keep class/function names stable in production bundles.
+                keepNames: true,
+            },
+            plugins: [
+                BuildPlatformSdkInjectPluginFactory.create(platformId, platformSdkInjectOptions),
+            ],
+            build: {
+                outDir: path.resolve(options.repoRoot, 'dist'),
+                emptyOutDir: true,
+            },
+        };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import { GameViteConfigFactory } from './GameViteConfigFactory.js';
+import type { GameViteConfigFactoryOptions } from './GameViteConfigFactory.js';
+import type { UserConfig } from 'vite';
+/**
+ * Creates a production-ready Vite config for Gamedev Land web games.
+ */
+export declare class GameViteConfig {
+    static create(options: GameViteConfigFactoryOptions): UserConfig;
+}
+export declare function createGameViteConfig(options: GameViteConfigFactoryOptions): UserConfig;
+export { GameViteConfigFactory };
+export type { GameViteConfigFactoryOptions };

package/dist/index.js

@@ -0,0 +1,13 @@
+import { GameViteConfigFactory } from './GameViteConfigFactory.js';
+/**
+ * Creates a production-ready Vite config for Gamedev Land web games.
+ */
+export class GameViteConfig {
+    static create(options) {
+        return GameViteConfigFactory.create(options);
+    }
+}
+export function createGameViteConfig(options) {
+    return GameViteConfig.create(options);
+}
+export { GameViteConfigFactory };

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@gamedevland/vite",
+  "version": "0.0.1",
+  "type": "module",
+  "description": "Vite build tooling for Gamedev Land HTML5 games.",
+  "license": "SEE LICENSE IN LICENSE",
+  "author": "Gamedev Land",
+  "homepage": "https://github.com/gamedevland/sdk#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gamedevland/sdk.git",
+    "directory": "packages/vite"
+  },
+  "bugs": {
+    "url": "https://github.com/gamedevland/sdk/issues"
+  },
+  "keywords": [
+    "gamedev",
+    "html5-game",
+    "vite",
+    "typescript",
+    "sdk"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "clean": "rimraf dist *.tsbuildinfo",
+    "pretypecheck": "npm run build -w @gamedevland/engine",
+    "typecheck": "tsc --noEmit",
+    "build": "npm run clean && tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json --resolve-full-paths"
+  },
+  "dependencies": {
+    "@gamedevland/engine": "0.0.2"
+  },
+  "peerDependencies": {
+    "vite": "^7.1.0 || ^8.0.0"
+  }
+}