@rollipop/core 0.0.0 → 0.1.0-alpha.0

package/CHANGELOG.md

@@ -0,0 +1,12 @@
+# @rollipop/core
+
+## 0.1.0-alpha.0
+
+### Minor Changes
+
+- 7a1d9a7: pre-alpha
+
+### Patch Changes
+
+- Updated dependencies [7a1d9a7]
+  - @rollipop/common@0.1.0-alpha.0

package/README.md

@@ -1 +1 @@
-# rollipop-empty
+# @rollipop/core

package/dist/chunk-BYW8Mqxw.js

@@ -0,0 +1,21 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __export = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+export { __require as n, __export as t };

package/dist/hmr-client.cjs

@@ -0,0 +1,212 @@
+import LogBox from '../LogBox/LogBox';
+import NativeRedBox from '../NativeModules/specs/NativeRedBox';
+
+//#region src/runtime/hmr-client.ts
+const Platform = require("./Platform").default;
+const prettyFormat = require("pretty-format");
+var HMRClient = class HMRClient {
+	static STARTUP_ERROR = "Expected HMRClient.setup() call at startup";
+	static MAX_PENDING_LOGS = 100;
+	enabled = true;
+	_socketHolder = null;
+	unavailableMessage = null;
+	compileErrorMessage = null;
+	pendingUpdatesCount = 0;
+	pendingLogs = [];
+	get DevLoadingView() {
+		return require("./DevLoadingView").default;
+	}
+	enable() {
+		if (this.unavailableMessage) {
+			throw new Error(this.unavailableMessage);
+		}
+		if (this._socketHolder == null) {
+			throw new Error(HMRClient.STARTUP_ERROR);
+		}
+		this.enabled = true;
+		this.showCompileErrorIfNeeded();
+	}
+	disable() {
+		this.enabled = false;
+	}
+	registerBundle(requestUrl) {
+		if (this._socketHolder == null) {
+			throw new Error(HMRClient.STARTUP_ERROR);
+		}
+		if (!requestUrl.startsWith(this._socketHolder.origin)) {
+			console.warn(`[HMR]: Cannot register bundle from unknown origin:\n${requestUrl}\n` + `(expected: ${this._socketHolder.origin})`);
+			return;
+		}
+	}
+	log(level, data) {
+		if (this._socketHolder == null) {
+			this.pendingLogs.push([level, data]);
+			if (this.pendingLogs.length > HMRClient.MAX_PENDING_LOGS) {
+				this.pendingLogs.shift();
+			}
+			return;
+		}
+		try {
+			const prettifyData = data.map((item) => typeof item === "string" ? item : prettyFormat.format(item, {
+				escapeString: true,
+				highlight: true,
+				maxDepth: 3,
+				min: true,
+				plugins: [prettyFormat.plugins.ReactElement]
+			}));
+			this.send({
+				type: "hmr:log",
+				level,
+				data: prettifyData
+			});
+		} catch {}
+	}
+	setup(platform, bundleEntry, host, port, isEnabled = true, protocol = "http") {
+		if (!__DEV__) {
+			throw new Error("HMR is only available in development mode");
+		}
+		if (this._socketHolder != null) {
+			throw new Error("Cannot initialize HMRClient more than once");
+		}
+		if (platform == null) {
+			throw new Error("Missing required parameter `platform`");
+		}
+		if (bundleEntry == null) {
+			throw new Error("Missing required parameter `bundleEntry`");
+		}
+		if (host == null) {
+			throw new Error("Missing required parameter `host`");
+		}
+		const serverHost = port !== null && port !== "" ? `${host}:${port}` : host;
+		const origin = `${protocol}://${serverHost}`;
+		const socket = new __ROLLIPOP_GLOBAL__.WebSocket(`${origin}/hot`);
+		this._socketHolder = {
+			socket,
+			origin
+		};
+		socket.addEventListener("open", () => {
+			socket.send(JSON.stringify({
+				type: "hmr:connected",
+				bundleEntry,
+				platform
+			}));
+			this.handleConnection();
+		});
+		socket.addEventListener("error", (event) => {
+			this.handleConnectionError(event.error, origin);
+		});
+		socket.addEventListener("message", (event) => {
+			this.handleMessage(event);
+		});
+		socket.addEventListener("close", (event) => {
+			this.handleClose(event);
+		});
+		__ROLLIPOP_GLOBAL__.__rolldown_runtime__.setup(socket);
+		this.enabled = isEnabled;
+	}
+	send(payload) {
+		if (this._socketHolder == null) {
+			return;
+		}
+		if (this._socketHolder.socket.readyState === WebSocket.OPEN) {
+			this._socketHolder.socket.send(JSON.stringify(payload));
+		}
+	}
+	flushEarlyLogs() {
+		if (this._socketHolder == null || this._socketHolder.socket.readyState !== WebSocket.OPEN) {
+			return;
+		}
+		for (const [level, data] of this.pendingLogs) {
+			this.send({
+				type: "hmr:log",
+				level,
+				data
+			});
+		}
+		this.pendingLogs.length = 0;
+	}
+	dismissRedbox() {
+		if (Platform.OS === "ios" && NativeRedBox != null && NativeRedBox.dismiss != null) {
+			NativeRedBox.dismiss();
+		} else {
+			const NativeExceptionsManager = require("../Core/NativeExceptionsManager").default;
+			if (NativeExceptionsManager != null && NativeExceptionsManager.dismissRedbox) {
+				NativeExceptionsManager.dismissRedbox();
+			}
+		}
+	}
+	showCompileErrorIfNeeded() {
+		if (this.compileErrorMessage == null) {
+			return;
+		}
+		this.dismissRedbox();
+		const error = new Error(this.compileErrorMessage);
+		this.compileErrorMessage = null;
+		Object.defineProperty(error, "preventSymbolication", { value: true });
+		throw error;
+	}
+	showUnavailableMessageIfNeeded() {
+		if (this.unavailableMessage == null) {
+			return;
+		}
+		this.DevLoadingView.hide();
+		if (this.enabled) {
+			this.DevLoadingView.showMessage("Fast Refresh disconnected. Reload app to reconnect.", "error", { dismissButton: true });
+			console.warn(this.unavailableMessage);
+		}
+	}
+	handleConnection() {
+		this.DevLoadingView.hide();
+		this.flushEarlyLogs();
+	}
+	handleConnectionError(error, origin) {
+		let errorMessage = "Cannot connect to Metro.\n\n" + "Try the following to fix the issue:\n" + "- Ensure that Metro is running and available on the same network";
+		if (Platform.OS === "ios") {
+			errorMessage += "- Ensure that the Metro URL is correctly set in AppDelegate";
+		} else {
+			errorMessage += `- Ensure that your device/emulator is connected to your machine and has USB debugging enabled - run 'adb devices' to see a list of connected devices\n` + `- If you're on a physical device connected to the same machine, run 'adb reverse tcp:8081 tcp:8081' to forward requests from your device\n` + `- If your device is on the same Wi-Fi network, set 'Debug server host & port for device' in 'Dev settings' to your machine's IP address and the port of the local dev server - e.g. 10.0.1.1:8081`;
+		}
+		errorMessage += `\n\nURL: ${origin}` + `\n\nError: ${error.message}`;
+		this.unavailableMessage ??= errorMessage;
+		this.showCompileErrorIfNeeded();
+	}
+	handleMessage(message) {
+		const data = JSON.parse(String(message.data));
+		if (!this.enabled && data.type.startsWith("hmr:")) {
+			return;
+		}
+		switch (data.type) {
+			case "hmr:update-start":
+				this.pendingUpdatesCount++;
+				this.compileErrorMessage = null;
+				this.DevLoadingView.showMessage("Refreshing...", "refresh");
+				break;
+			case "hmr:update":
+				this.dismissRedbox();
+				LogBox.clearAllLogs();
+				break;
+			case "hmr:update-done":
+				this.pendingUpdatesCount = Math.max(0, this.pendingUpdatesCount - 1);
+				if (this.pendingUpdatesCount === 0) {
+					this.DevLoadingView.hide();
+				}
+				break;
+			case "hmr:error":
+				this.compileErrorMessage = data.payload.message;
+				this.showCompileErrorIfNeeded();
+				break;
+		}
+	}
+	handleClose(event) {
+		const { code, reason } = event;
+		const isNormalOrUnsetCloseReason = code === 1e3 || code === 1005;
+		const message = isNormalOrUnsetCloseReason ? "Disconnected from Metro." : `Disconnected from Metro (${code}: "${reason}").`;
+		this.unavailableMessage ??= message + "\n\n" + "To reconnect:\n" + "- Ensure that Metro is running and available on the same network\n" + "- Reload this app (will trigger further help if Metro cannot be connected to)\n";
+		this.showUnavailableMessageIfNeeded();
+	}
+};
+const instance = new HMRClient();
+var hmr_client_default = Object.defineProperty(instance, "default", { get: () => instance });
+
+//#endregion
+module.exports = hmr_client_default;

package/dist/hmr-runtime.js

@@ -0,0 +1,158 @@
+//#region src/runtime/react-refresh-utils.ts
+function isReactRefreshBoundary(moduleExports) {
+	if (__ROLLIPOP_GLOBAL__.__ReactRefresh.isLikelyComponentType(moduleExports)) {
+		return true;
+	}
+	if (moduleExports === undefined || moduleExports === null || typeof moduleExports !== "object") {
+		return false;
+	}
+	var hasExports = false;
+	var areAllExportsComponents = true;
+	for (var key in moduleExports) {
+		hasExports = true;
+		if (key === "__esModule") {
+			continue;
+		}
+		var exportValue = moduleExports[key];
+		if (!__ROLLIPOP_GLOBAL__.__ReactRefresh.isLikelyComponentType(exportValue)) {
+			areAllExportsComponents = false;
+		}
+	}
+	return hasExports && areAllExportsComponents;
+}
+let timer = null;
+function enqueueUpdate() {
+	if (timer) {
+		return;
+	}
+	timer = setTimeout(() => {
+		__ROLLIPOP_GLOBAL__.__ReactRefresh.performReactRefresh();
+		timer = null;
+	}, 50);
+}
+
+//#endregion
+//#region src/runtime/hmr-runtime.ts
+var BaseDevRuntime = DevRuntime;
+var ModuleHotContext = class {
+	acceptCallbacks = [];
+	constructor(moduleId, devRuntime) {
+		this.moduleId = moduleId;
+		this.devRuntime = devRuntime;
+	}
+	get refresh() {
+		return __ROLLIPOP_GLOBAL__.__ReactRefresh;
+	}
+	get refreshUtils() {
+		return {
+			isReactRefreshBoundary,
+			enqueueUpdate
+		};
+	}
+	accept(...args) {
+		if (args.length === 1) {
+			const [cb] = args;
+			const acceptingPath = this.moduleId;
+			this.acceptCallbacks.push({
+				deps: [acceptingPath],
+				fn: cb
+			});
+		} else if (args.length === 0) {} else {
+			throw new Error("Invalid arguments for `import.meta.hot.accept`");
+		}
+	}
+	invalidate() {
+		if (ReactNativeDevRuntime.socket == null || ReactNativeDevRuntime.socket.readyState !== WebSocket.OPEN) {
+			return;
+		}
+		ReactNativeDevRuntime.socket.send(JSON.stringify({
+			type: "hmr:invalidate",
+			moduleId: this.moduleId
+		}));
+	}
+};
+var ReactNativeDevRuntime = class ReactNativeDevRuntime extends BaseDevRuntime {
+	static socket = null;
+	static queuedMessages = [];
+	moduleHotContexts = new Map();
+	moduleHotContextsToBeUpdated = new Map();
+	constructor() {
+		const messenger = { send(message) {
+			if (ReactNativeDevRuntime.socket === null || ReactNativeDevRuntime.socket.readyState !== WebSocket.OPEN) {
+				ReactNativeDevRuntime.queuedMessages.push(JSON.stringify(message));
+				return;
+			}
+			ReactNativeDevRuntime.socket.send(JSON.stringify(message));
+		} };
+		super(messenger);
+	}
+	createModuleHotContext(moduleId) {
+		const hotContext = new ModuleHotContext(moduleId, this);
+		if (this.moduleHotContexts.has(moduleId)) {
+			this.moduleHotContextsToBeUpdated.set(moduleId, hotContext);
+		} else {
+			this.moduleHotContexts.set(moduleId, hotContext);
+		}
+		return hotContext;
+	}
+	applyUpdates(boundaries) {
+		for (let [moduleId, _acceptedVia] of boundaries) {
+			const hotContext = this.moduleHotContexts.get(moduleId);
+			if (hotContext) {
+				const acceptCallbacks = hotContext.acceptCallbacks;
+				acceptCallbacks.filter((cb) => {
+					cb.fn(this.modules[moduleId].exports);
+				});
+			}
+		}
+		this.moduleHotContextsToBeUpdated.forEach((hotContext, moduleId) => {
+			this.moduleHotContexts.set(moduleId, hotContext);
+		});
+		this.moduleHotContextsToBeUpdated.clear();
+	}
+	setup(socket) {
+		if (ReactNativeDevRuntime.socket != null) {
+			console.warn("[HMR]: ReactNativeDevRuntime already setup");
+			return;
+		}
+		if (socket.readyState !== WebSocket.OPEN) {
+			socket.addEventListener("open", () => {
+				this.flushQueuedMessages(socket);
+			});
+		} else {
+			this.flushQueuedMessages(socket);
+		}
+		socket.addEventListener("message", (event) => {
+			const message = JSON.parse(event.data);
+			switch (message.type) {
+				case "hmr:update":
+					this.evaluate(message.code);
+					break;
+				case "hmr:reload":
+					this.reload();
+					break;
+			}
+		});
+		ReactNativeDevRuntime.socket = socket;
+	}
+	flushQueuedMessages(socket) {
+		for (const message of ReactNativeDevRuntime.queuedMessages) {
+			socket.send(message);
+		}
+		ReactNativeDevRuntime.queuedMessages.length = 0;
+	}
+	evaluate(code, sourceURL) {
+		if (__ROLLIPOP_GLOBAL__.globalEvalWithSourceUrl) {
+			__ROLLIPOP_GLOBAL__.globalEvalWithSourceUrl(code, sourceURL);
+		} else {
+			eval(code);
+		}
+	}
+	reload() {
+		const moduleName = "DevSettings";
+		(__ROLLIPOP_GLOBAL__.__turboModuleProxy ? __ROLLIPOP_GLOBAL__.__turboModuleProxy(moduleName) : __ROLLIPOP_GLOBAL__.nativeModuleProxy[moduleName]).reload();
+	}
+};
+__ROLLIPOP_GLOBAL__.__rolldown_runtime__ = new ReactNativeDevRuntime();
+
+//#endregion

package/dist/hmr-shims.js

@@ -0,0 +1,10 @@
+//#region src/runtime/hmr-shims.ts
+/**
+* For CJS modules without export statements, an error occurs when the HMR boundary references a non-existent module identifier (appears to be a rolldown bug).
+* I've added an empty module object as a temporary workaround for the reference issue.
+* 
+* @see https://github.com/rolldown/rolldown/pull/7544
+*/
+var module = { exports: {} };
+
+//#endregion