rollipop 1.0.0-alpha.21 → 1.0.0-alpha.23

package/dist/constants.js

@@ -0,0 +1,146 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+//#region src/constants.ts
+var constants_exports = /* @__PURE__ */ __exportAll({
+	DEFAULT_ASSET_EXTENSIONS: () => DEFAULT_ASSET_EXTENSIONS,
+	DEFAULT_ASSET_REGISTRY_PATH: () => DEFAULT_ASSET_REGISTRY_PATH,
+	DEFAULT_ENV_FILE: () => DEFAULT_ENV_FILE,
+	DEFAULT_ENV_PREFIX: () => DEFAULT_ENV_PREFIX,
+	DEFAULT_HMR_CLIENT_PATH: () => DEFAULT_HMR_CLIENT_PATH,
+	DEFAULT_IMAGE_EXTENSIONS: () => DEFAULT_IMAGE_EXTENSIONS,
+	DEFAULT_REACT_NATIVE_GLOBAL_IDENTIFIERS: () => DEFAULT_REACT_NATIVE_GLOBAL_IDENTIFIERS,
+	DEFAULT_RESOLVER_ALIAS_FIELDS: () => DEFAULT_RESOLVER_ALIAS_FIELDS,
+	DEFAULT_RESOLVER_CONDITION_NAMES: () => DEFAULT_RESOLVER_CONDITION_NAMES,
+	DEFAULT_RESOLVER_MAIN_FIELDS: () => DEFAULT_RESOLVER_MAIN_FIELDS,
+	DEFAULT_RUNTIME_TARGET: () => DEFAULT_RUNTIME_TARGET,
+	DEFAULT_SOURCE_EXTENSIONS: () => DEFAULT_SOURCE_EXTENSIONS,
+	GLOBAL_IDENTIFIER: () => GLOBAL_IDENTIFIER,
+	IMAGE_EXTENSIONS: () => IMAGE_EXTENSIONS,
+	ROLLIPOP_VERSION: () => ROLLIPOP_VERSION
+});
+const ROLLIPOP_VERSION = "1.0.0-alpha.23";
+const GLOBAL_IDENTIFIER = "global";
+/**
+* @see {@link https://github.com/facebook/metro/blob/0.81.x/docs/Configuration.md#resolvermainfields}
+*/
+const DEFAULT_RESOLVER_MAIN_FIELDS = [
+	"react-native",
+	"browser",
+	"main"
+];
+const DEFAULT_RESOLVER_ALIAS_FIELDS = [["react-native"], ["browser"]];
+const DEFAULT_RESOLVER_CONDITION_NAMES = ["react-native"];
+/**
+* Unlike the Metro bundler configuration, this prioritizes resolving TypeScript and ESM first.
+*
+* @see {@link https://github.com/facebook/metro/blob/0.81.x/packages/metro-config/src/defaults/defaults.js}
+* @see {@link https://github.com/facebook/metro/blob/0.81.x/packages/metro-file-map/src/workerExclusionList.js}
+*/
+const DEFAULT_SOURCE_EXTENSIONS = [
+	"ts",
+	"tsx",
+	"js",
+	"jsx",
+	"mjs",
+	"cjs",
+	"json"
+];
+const DEFAULT_IMAGE_EXTENSIONS = [
+	"bmp",
+	"gif",
+	"jpg",
+	"jpeg",
+	"png",
+	"psd",
+	"svg",
+	"webp"
+];
+const IMAGE_EXTENSIONS = [
+	...DEFAULT_IMAGE_EXTENSIONS,
+	"tiff",
+	"ktx"
+];
+const DEFAULT_ASSET_EXTENSIONS = [
+	...DEFAULT_IMAGE_EXTENSIONS,
+	"xml",
+	"m4v",
+	"mov",
+	"mp4",
+	"mpeg",
+	"mpg",
+	"webm",
+	"aac",
+	"aiff",
+	"caf",
+	"m4a",
+	"mp3",
+	"wav",
+	"html",
+	"pdf",
+	"yaml",
+	"yml",
+	"otf",
+	"ttf",
+	"zip"
+];
+const DEFAULT_ASSET_REGISTRY_PATH = "react-native/Libraries/Image/AssetRegistry.js";
+const DEFAULT_HMR_CLIENT_PATH = "react-native/Libraries/Utilities/HMRClient.js";
+const DEFAULT_REACT_NATIVE_GLOBAL_IDENTIFIERS = [
+	GLOBAL_IDENTIFIER,
+	"Promise",
+	"regeneratorRuntime",
+	"XMLHttpRequest",
+	"FormData",
+	"fetch",
+	"Headers",
+	"Request",
+	"Response",
+	"WebSocket",
+	"Blob",
+	"File",
+	"FileReader",
+	"URL",
+	"URLSearchParams",
+	"AbortController",
+	"AbortSignal",
+	"queueMicrotask",
+	"setImmediate",
+	"clearImmediate",
+	"requestIdleCallback",
+	"cancelIdleCallback",
+	"setTimeout",
+	"clearTimeout",
+	"setInterval",
+	"clearInterval",
+	"requestAnimationFrame",
+	"cancelAnimationFrame",
+	"DOMRect",
+	"DOMRectReadOnly",
+	"DOMRectList",
+	"HTMLCollection",
+	"NodeList",
+	"Node",
+	"Document",
+	"CharacterData",
+	"Text",
+	"Element",
+	"HTMLElement",
+	"IntersectionObserver",
+	"MutationObserver",
+	"MutationRecord",
+	"EventCounts",
+	"Performance",
+	"PerformanceEntry",
+	"PerformanceEventTiming",
+	"PerformanceLongTaskTiming",
+	"PerformanceMark",
+	"PerformanceMeasure",
+	"PerformanceObserver",
+	"PerformanceObserverEntryList",
+	"PerformanceResourceTiming",
+	"TaskAttributionTiming"
+];
+const DEFAULT_ENV_PREFIX = "ROLLIPOP_";
+const DEFAULT_ENV_FILE = ".env";
+const DEFAULT_RUNTIME_TARGET = "hermes-v1";
+//#endregion
+export { DEFAULT_ASSET_EXTENSIONS, DEFAULT_ASSET_REGISTRY_PATH, DEFAULT_ENV_FILE, DEFAULT_ENV_PREFIX, DEFAULT_HMR_CLIENT_PATH, DEFAULT_REACT_NATIVE_GLOBAL_IDENTIFIERS, DEFAULT_RESOLVER_ALIAS_FIELDS, DEFAULT_RESOLVER_CONDITION_NAMES, DEFAULT_RESOLVER_MAIN_FIELDS, DEFAULT_RUNTIME_TARGET, DEFAULT_SOURCE_EXTENSIONS, GLOBAL_IDENTIFIER, IMAGE_EXTENSIONS, ROLLIPOP_VERSION, constants_exports };

package/dist/core/assets.d.ts

@@ -0,0 +1,91 @@
+declare namespace assets_d_exports {
+  export { AssetContext, AssetData, AssetDataFiltered, AssetDataWithoutFiles, AssetInfo, AssetScale, copyAssetsToDestination, generateAssetRegistryCode, getAssetPriority, getSuffixedPath, platformSuffixPattern, resolveAssetPath, resolveScaledAssets, stripSuffix };
+}
+/**
+ * **NOTE**: Type definitions are ported from `metro` implementation.
+ *
+ * @see https://github.com/facebook/metro/blob/0.81.x/packages/metro/src/Assets.js
+ */
+interface AssetContext {
+  platform: string;
+  preferNativePlatform: boolean;
+}
+interface AssetInfo {
+  files: string[];
+  hash: string;
+  name: string;
+  scales: number[];
+  type: string;
+}
+interface AssetDataWithoutFiles {
+  __packager_asset: boolean;
+  fileSystemLocation: string;
+  hash: string;
+  httpServerLocation: string;
+  name: string;
+  scales: AssetScale[];
+  type: string;
+  width?: number;
+  height?: number;
+}
+interface AssetDataFiltered {
+  __packager_asset: boolean;
+  hash: string;
+  httpServerLocation: string;
+  name: string;
+  scales: AssetScale[];
+  type: string;
+  width?: number;
+  height?: number;
+}
+interface AssetData extends AssetDataWithoutFiles {
+  id: string;
+  files: string[];
+}
+type AssetScale = 0.75 | 1 | 1.5 | 2 | 3;
+interface ResolveScaledAssetsOptions {
+  projectRoot: string;
+  assetPath: string;
+  platform: string;
+  preferNativePlatform: boolean;
+}
+declare function resolveScaledAssets(options: ResolveScaledAssetsOptions): Promise<AssetData>;
+declare function platformSuffixPattern(context: AssetContext): string;
+declare function stripSuffix(assetPath: string, context: AssetContext): string;
+declare function getAssetPriority(assetPath: string, context: AssetContext): 0 | 3 | 2 | 1;
+interface GetSuffixedPathOptions {
+  scale?: AssetScale;
+  platform?: string;
+}
+/**
+ * add suffix to asset path
+ *
+ * ```js
+ * // assetPath input
+ * '/path/to/assets/image.png'
+ *
+ * // `platform` suffixed
+ * '/path/to/assets/image.android.png'
+ *
+ * // `scale` suffixed
+ * '/path/to/assets/image@1x.png'
+ *
+ * // both `platform` and `scale` suffixed
+ * '/path/to/assets/image@1x.android.png'
+ * ```
+ */
+declare function getSuffixedPath(assetPath: string, context: AssetContext, options: GetSuffixedPathOptions): string;
+declare function resolveAssetPath(assetPath: string, context: AssetContext, scale: AssetScale): string;
+interface CopyAssetsToDestinationOptions {
+  assets: AssetData[];
+  assetsDir: string;
+  platform: string;
+  preferNativePlatform: boolean;
+}
+/**
+ * @see https://github.com/facebook/react-native/blob/0.83-stable/packages/community-cli-plugin/src/commands/bundle/assetPathUtils.js
+ */
+declare function copyAssetsToDestination(options: CopyAssetsToDestinationOptions): Promise<undefined>;
+declare function generateAssetRegistryCode(assetRegistryPath: string, asset: AssetData): string;
+//#endregion
+export { assets_d_exports };

package/dist/core/assets.js

@@ -0,0 +1,244 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { IMAGE_EXTENSIONS } from "../constants.js";
+import { md5 } from "../utils/hash.js";
+import { DEV_SERVER_ASSET_PATH } from "../server/constants.js";
+import "../server/index.js";
+import fs from "node:fs";
+import path from "node:path";
+import { isNotNil } from "es-toolkit";
+import { imageSize } from "image-size";
+//#region src/core/assets.ts
+/**
+* **NOTE**: Type definitions are ported from `metro` implementation.
+*
+* @see https://github.com/facebook/metro/blob/0.81.x/packages/metro/src/Assets.js
+*/
+var assets_exports = /* @__PURE__ */ __exportAll({
+	copyAssetsToDestination: () => copyAssetsToDestination,
+	generateAssetRegistryCode: () => generateAssetRegistryCode,
+	getAssetPriority: () => getAssetPriority,
+	getSuffixedPath: () => getSuffixedPath,
+	platformSuffixPattern: () => platformSuffixPattern,
+	resolveAssetPath: () => resolveAssetPath,
+	resolveScaledAssets: () => resolveScaledAssets,
+	stripSuffix: () => stripSuffix
+});
+const SCALE_PATTERN = "@(\\d+\\.?\\d*)x";
+const IMAGE_ASSET_TYPES = new Set(IMAGE_EXTENSIONS);
+/**
+* key: platform,
+* value: allowed scales
+*
+* @see https://github.com/facebook/react-native/blob/0.83-stable/packages/community-cli-plugin/src/commands/bundle/filterPlatformAssetScales.js#L11
+*/
+const ALLOW_SCALES = { ios: [
+	1,
+	2,
+	3
+] };
+/**
+* @see https://developer.android.com/training/multiscreen/screendensities#TaskProvideAltBmp
+*/
+const ANDROID_ASSET_QUALIFIER = {
+	.75: "ldpi",
+	1: "mdpi",
+	1.5: "hdpi",
+	2: "xhdpi",
+	3: "xxhdpi",
+	4: "xxxhdpi"
+};
+async function resolveScaledAssets(options) {
+	const { projectRoot, assetPath, platform, preferNativePlatform } = options;
+	const context = {
+		platform,
+		preferNativePlatform
+	};
+	const extension = path.extname(assetPath);
+	const type = extension.substring(1);
+	const relativePath = path.relative(projectRoot, assetPath);
+	const dirname = path.dirname(assetPath);
+	const files = fs.readdirSync(dirname);
+	const stripedBasename = stripSuffix(assetPath, context);
+	const suffixPattern = platformSuffixPattern(context);
+	const assetRegExp = new RegExp(`${stripedBasename}(${SCALE_PATTERN})?(?:${suffixPattern})?${extension}$`);
+	const scaledAssets = {};
+	for (const file of files.sort((a, b) => getAssetPriority(b, context) - getAssetPriority(a, context))) {
+		const match = assetRegExp.exec(file);
+		if (match) {
+			const [, , scale = "1"] = match;
+			if (scaledAssets[scale]) continue;
+			scaledAssets[scale] = file;
+		}
+	}
+	if (!(Object.keys(scaledAssets).length && scaledAssets[1])) throw new Error(`cannot resolve base asset of ${assetPath}`);
+	const imageData = fs.readFileSync(assetPath);
+	const dimensions = IMAGE_ASSET_TYPES.has(type) ? imageSize(imageData) : void 0;
+	const filteredScaledAssets = Object.entries(scaledAssets).map(([scale, file]) => ({
+		scale: parseFloat(scale),
+		file
+	})).filter(({ scale }) => ALLOW_SCALES[platform]?.includes(scale) ?? true).reduce((acc, { scale, file }) => {
+		acc.files.push(file);
+		acc.scales.push(scale);
+		return acc;
+	}, {
+		scales: [],
+		files: []
+	});
+	return {
+		__packager_asset: true,
+		id: assetPath,
+		name: stripedBasename.replace(extension, ""),
+		type,
+		width: dimensions?.width,
+		height: dimensions?.height,
+		files: filteredScaledAssets.files,
+		scales: filteredScaledAssets.scales,
+		fileSystemLocation: path.dirname(assetPath),
+		httpServerLocation: path.join(DEV_SERVER_ASSET_PATH, path.dirname(relativePath)),
+		hash: md5(imageData)
+	};
+}
+function platformSuffixPattern(context) {
+	return [context.platform, context.preferNativePlatform ? "native" : null].filter(isNotNil).map((platform) => `.${platform}`).join("|");
+}
+function stripSuffix(assetPath, context) {
+	const basename = path.basename(assetPath);
+	const extension = path.extname(assetPath);
+	const suffixPattern = platformSuffixPattern(context);
+	return basename.replace(new RegExp(`(${SCALE_PATTERN})?(?:${suffixPattern})?${extension}$`), "");
+}
+function getAssetPriority(assetPath, context) {
+	const suffixPattern = platformSuffixPattern(context);
+	if (new RegExp(`${SCALE_PATTERN}(?:${suffixPattern})`).test(assetPath)) return 3;
+	else if (new RegExp(`(?:${suffixPattern})`).test(assetPath)) return 2;
+	else if (new RegExp(`${SCALE_PATTERN}`).test(assetPath)) return 1;
+	return 0;
+}
+function addSuffix(assetPath, context, options) {
+	const extension = path.extname(assetPath);
+	return stripSuffix(assetPath, context).concat(options?.scale ? `@${options.scale}x` : "").concat(options?.platform ? `.${options.platform}${extension}` : extension);
+}
+/**
+* add suffix to asset path
+*
+* ```js
+* // assetPath input
+* '/path/to/assets/image.png'
+*
+* // `platform` suffixed
+* '/path/to/assets/image.android.png'
+*
+* // `scale` suffixed
+* '/path/to/assets/image@1x.png'
+*
+* // both `platform` and `scale` suffixed
+* '/path/to/assets/image@1x.android.png'
+* ```
+*/
+function getSuffixedPath(assetPath, context, options) {
+	const suffixedBasename = addSuffix(assetPath, context, {
+		scale: options?.scale,
+		platform: options?.platform
+	});
+	const dirname = path.dirname(assetPath);
+	return path.join(dirname, suffixedBasename);
+}
+function resolveAssetPath(assetPath, context, scale) {
+	const suffixedPaths = [
+		getSuffixedPath(assetPath, context, {
+			scale,
+			platform: context.platform
+		}),
+		context.preferNativePlatform ? getSuffixedPath(assetPath, context, {
+			scale,
+			platform: "native"
+		}) : null,
+		getSuffixedPath(assetPath, context, { scale })
+	].filter(isNotNil);
+	/**
+	* When scale is 1, filename can be suffixed or non-suffixed(`image.png`).
+	*
+	* - Suffixed
+	*   - `filename.<platform>@<scale>x.ext`
+	*   - `filename.<platform>.ext`
+	*   - `filename@<scale>x.ext`
+	* - Non suffixed
+	*   - `filename.ext`
+	*
+	* 1. Resolve non-suffixed asset first.
+	* 2. If file is not exist, resolve suffixed path.
+	*/
+	if (scale === 1) try {
+		fs.statSync(assetPath);
+		return assetPath;
+	} catch {}
+	for (const suffixedPath of suffixedPaths) try {
+		fs.statSync(suffixedPath);
+		return suffixedPath;
+	} catch {}
+	throw new Error(`cannot resolve asset path for ${assetPath}`);
+}
+/**
+* @see https://github.com/facebook/react-native/blob/0.83-stable/packages/community-cli-plugin/src/commands/bundle/assetPathUtils.js
+*/
+async function copyAssetsToDestination(options) {
+	const { assets, platform, assetsDir, preferNativePlatform } = options;
+	const context = {
+		platform,
+		preferNativePlatform
+	};
+	const mkdirWithAssertPath = (targetPath) => {
+		const dirname = path.dirname(targetPath);
+		fs.mkdirSync(dirname, { recursive: true });
+	};
+	return Promise.all(assets.map((asset) => {
+		return Promise.all(asset.scales.map(async (scale) => {
+			if (platform !== "android") {
+				const from = resolveAssetPath(asset.id, context, scale);
+				const to = path.join(assetsDir, getIosAssetDestinationPath(asset, scale));
+				mkdirWithAssertPath(to);
+				return fs.copyFileSync(from, to);
+			}
+			const from = resolveAssetPath(asset.id, context, scale);
+			const to = path.join(assetsDir, getAndroidAssetDestinationPath(asset, scale));
+			mkdirWithAssertPath(to);
+			fs.copyFileSync(from, to);
+		})).then(() => void 0);
+	})).then(() => void 0);
+}
+/**
+* @see https://github.com/facebook/react-native/blob/0.83-stable/packages/community-cli-plugin/src/commands/bundle/getAssetDestPathIOS.js
+*/
+function getIosAssetDestinationPath(asset, scale) {
+	const suffix = scale === 1 ? "" : `@${scale}x`;
+	const fileName = `${asset.name + suffix}.${asset.type}`;
+	const devServerBasePath = asset.httpServerLocation.at(0) === "/" ? asset.httpServerLocation.slice(1) : asset.httpServerLocation;
+	return path.join(devServerBasePath.replace(/\.\.\//g, "_"), fileName);
+}
+function getAndroidAssetDestinationPath(asset, scale) {
+	const assetQualifierSuffix = ANDROID_ASSET_QUALIFIER[scale];
+	const assetName = `${asset.httpServerLocation.at(0) === "/" ? asset.httpServerLocation.slice(1) : asset.httpServerLocation}/${asset.name}`.toLowerCase().replace(/\//g, "_").replace(/(?:[^a-z0-9_])/g, "").replace(/^assets_/, "");
+	if (!assetQualifierSuffix) throw new Error(`invalid asset qualifier: ${asset.id}`);
+	return path.join(isDrawable(asset.type) ? `drawable-${assetQualifierSuffix}` : "raw", `${assetName}.${asset.type}`);
+}
+/**
+* @see https://developer.android.com/guide/topics/resources/drawable-resource
+*/
+function isDrawable(type) {
+	return [
+		"gif",
+		"heic",
+		"heif",
+		"jpeg",
+		"jpg",
+		"ktx",
+		"png",
+		"webp",
+		"xml"
+	].includes(type);
+}
+function generateAssetRegistryCode(assetRegistryPath, asset) {
+	return `module.exports = require('${assetRegistryPath}').registerAsset(${JSON.stringify(asset)});`;
+}
+//#endregion
+export { assets_exports, copyAssetsToDestination, generateAssetRegistryCode, resolveAssetPath, resolveScaledAssets };

package/dist/core/bundler.d.ts

@@ -0,0 +1,15 @@
+import { BuildOptions, DevEngine, DevEngineOptions } from "./types.js";
+import { ResolvedConfig } from "../config/defaults.js";
+import * as rolldown from "@rollipop/rolldown";
+
+//#region src/core/bundler.d.ts
+declare class Bundler {
+  private readonly config;
+  static devEngine(config: ResolvedConfig, buildOptions: Omit<BuildOptions, 'dev' | 'outfile'>, devEngineOptions: DevEngineOptions): Promise<DevEngine>;
+  static createId(config: ResolvedConfig, buildOptions: BuildOptions): string;
+  private static createContext;
+  constructor(config: ResolvedConfig);
+  build(buildOptions: BuildOptions): Promise<rolldown.OutputChunk>;
+}
+//#endregion
+export { Bundler };

package/dist/core/bundler.js

@@ -0,0 +1,80 @@
+import { Logo } from "../common/logo.js";
+import { resolveBuildOptions } from "../utils/build-options.js";
+import { createId } from "../utils/id.js";
+import { FileStorage } from "./fs/storage.js";
+import { getOverrideOptions, getOverrideOptionsForDevServer, resolveRolldownOptions } from "./rolldown.js";
+import fs from "node:fs";
+import path from "node:path";
+import { invariant, merge } from "es-toolkit";
+import * as rolldown from "@rollipop/rolldown";
+import { dev } from "@rollipop/rolldown/experimental";
+//#region src/core/bundler.ts
+var Bundler = class Bundler {
+	config;
+	static async devEngine(config, buildOptions, devEngineOptions) {
+		const buildType = "serve";
+		const resolvedBuildOptions = resolveBuildOptions(config, buildOptions);
+		const context = Bundler.createContext(buildType, config, resolvedBuildOptions);
+		const { input = {}, output = {} } = await resolveRolldownOptions(context, config, resolvedBuildOptions, devEngineOptions);
+		const devServerOptions = getOverrideOptionsForDevServer(resolvedBuildOptions);
+		const devEngine = await dev(merge(input, devServerOptions.input), merge(output, devServerOptions.output), {
+			watch: config.watcher,
+			...devEngineOptions
+		});
+		Object.defineProperty(devEngine, "getContext", {
+			value: () => context,
+			enumerable: true,
+			configurable: false
+		});
+		return devEngine;
+	}
+	static createId(config, buildOptions) {
+		return createId(config, buildOptions);
+	}
+	static createContext(buildType, config, buildOptions) {
+		return {
+			id: Bundler.createId(config, buildOptions),
+			root: config.root,
+			storage: FileStorage.getInstance(config.root),
+			buildType,
+			state: {
+				revision: 0,
+				latestBuildStartTime: 0
+			}
+		};
+	}
+	constructor(config) {
+		this.config = config;
+		Logo.printOnce();
+	}
+	async build(buildOptions) {
+		const buildType = "build";
+		const resolvedBuildOptions = resolveBuildOptions(this.config, buildOptions);
+		const context = Bundler.createContext(buildType, this.config, resolvedBuildOptions);
+		const sourcemap = resolvedBuildOptions.sourcemap ? true : false;
+		const { input = {}, output = {} } = await resolveRolldownOptions(context, this.config, resolvedBuildOptions);
+		const overrideOptions = getOverrideOptions();
+		const mergedInput = merge(input, overrideOptions.input);
+		const mergedOutput = merge(output, overrideOptions.output);
+		const rolldownBuildOptions = {
+			...mergedInput,
+			output: {
+				...mergedOutput,
+				sourcemap
+			},
+			write: Boolean(resolvedBuildOptions.outfile)
+		};
+		const chunk = (await rolldown.build(rolldownBuildOptions)).output[0];
+		invariant(chunk, "Bundled chunk is not found");
+		if (resolvedBuildOptions.outfile && chunk.sourcemapFileName && resolvedBuildOptions.sourcemapOutfile) {
+			const outputDir = path.dirname(resolvedBuildOptions.outfile);
+			const sourcemapDir = path.dirname(resolvedBuildOptions.sourcemapOutfile);
+			const sourcemapFile = path.join(outputDir, chunk.sourcemapFileName);
+			if (!fs.existsSync(sourcemapDir)) fs.mkdirSync(sourcemapDir, { recursive: true });
+			fs.renameSync(sourcemapFile, resolvedBuildOptions.sourcemapOutfile);
+		}
+		return chunk;
+	}
+};
+//#endregion
+export { Bundler };

package/dist/core/env.d.ts

@@ -0,0 +1,11 @@
+import { Config } from "../config/types.js";
+//#region src/core/env.d.ts
+interface LoadEnvOptions {
+  envDir: string;
+  envPrefix: string;
+  envFile: string;
+  mode?: Config['mode'];
+}
+declare function loadEnv(options: LoadEnvOptions): Record<string, string>;
+//#endregion
+export { LoadEnvOptions, loadEnv };

package/dist/core/env.js

@@ -0,0 +1,36 @@
+import { logger } from "../logger.js";
+import fs from "node:fs";
+import path from "node:path";
+import { invariant, isNotNil } from "es-toolkit";
+import dotenv from "dotenv";
+import dotenvExpand from "dotenv-expand";
+//#region src/core/env.ts
+function loadEnv(options) {
+	const { envDir, envPrefix, envFile, mode } = options;
+	invariant(envPrefix.length > 0, "`envPrefix` is required");
+	invariant(envFile.length > 0, "`envFile` is required");
+	const env = {};
+	const envFilesToLoad = [
+		envFile,
+		`${envFile}.local`,
+		mode ? `${envFile}.${mode}` : null,
+		mode ? `${envFile}.${mode}.local` : null
+	].filter(isNotNil);
+	for (const file of envFilesToLoad) {
+		const envPath = path.resolve(envDir, file);
+		if (!fs.existsSync(envPath)) continue;
+		logger.trace(`Loading environment variables from ${envPath}`);
+		const parsed = dotenv.parse(fs.readFileSync(envPath, "utf-8"));
+		const expanded = dotenvExpand.expand({
+			parsed,
+			processEnv: {}
+		});
+		if (expanded.parsed) Object.entries(expanded.parsed).forEach(([key, value]) => {
+			if (key.startsWith(envPrefix)) env[key] = key in process.env ? process.env[key] : value;
+		});
+	}
+	logger.trace("Loaded environment variables:", env);
+	return env;
+}
+//#endregion
+export { loadEnv };

package/dist/core/fs/data.js

@@ -0,0 +1,9 @@
+import { SHARED_DATA_PATH } from "../../common/constants.js";
+import "node:fs";
+import path from "node:path";
+//#region src/core/fs/data.ts
+function getSharedDataPath(basePath) {
+	return path.join(basePath, SHARED_DATA_PATH);
+}
+//#endregion
+export { getSharedDataPath };

package/dist/core/fs/storage.d.ts

@@ -0,0 +1,15 @@
+import { FileStorageData } from "../../common/types.js";
+
+//#region src/core/fs/storage.d.ts
+declare class FileStorage {
+  private readonly basePath;
+  private static instance;
+  private dataFilePath;
+  private data;
+  static getInstance(basePath: string): FileStorage;
+  private constructor();
+  get(): FileStorageData;
+  set(data: Partial<FileStorageData>): void;
+}
+//#endregion
+export { FileStorage };

package/dist/core/fs/storage.js

@@ -0,0 +1,31 @@
+import { getSharedDataPath } from "./data.js";
+import fs from "node:fs";
+import path from "node:path";
+import { merge } from "es-toolkit";
+//#region src/core/fs/storage.ts
+const DEFAULT_DATA = { build: {} };
+var FileStorage = class FileStorage {
+	basePath;
+	static instance = null;
+	dataFilePath;
+	data;
+	static getInstance(basePath) {
+		if (FileStorage.instance == null) FileStorage.instance = new FileStorage(basePath);
+		return FileStorage.instance;
+	}
+	constructor(basePath) {
+		this.basePath = basePath;
+		this.dataFilePath = path.join(getSharedDataPath(basePath), "rollipop.json");
+		if (fs.existsSync(this.dataFilePath)) this.data = JSON.parse(fs.readFileSync(this.dataFilePath, "utf-8"));
+		else this.data = DEFAULT_DATA;
+	}
+	get() {
+		return this.data;
+	}
+	set(data) {
+		this.data = merge(this.data, data);
+		fs.writeFileSync(this.dataFilePath, JSON.stringify(this.data, null, 2));
+	}
+};
+//#endregion
+export { FileStorage };