devframe 0.2.1 → 0.2.3

package/dist/{shared-state-q9-1EOSX.mjs → shared-state-u0y123fi.mjs}

@@ -4,7 +4,7 @@ import { nanoid } from "./utils/nanoid.mjs";
 var NOTHING = Symbol.for("immer-nothing");
 var DRAFTABLE = Symbol.for("immer-draftable");
 var DRAFT_STATE = Symbol.for("immer-state");
-var errors = process.env.NODE_ENV !== "production" ? [
+var errors = [
 	function(plugin) {
 		return `The plugin for '${plugin}' has not been loaded into Immer. To enable the plugin, import and call \`enable${plugin}()\` when initializing your application.`;
 	},
@@ -31,9 +31,9 @@ var errors = process.env.NODE_ENV !== "production" ? [
 	function(thing) {
 		return `'original' expects a draft, got: ${thing}`;
 	}
-] : [];
+];
 function die(error, ...args) {
-	if (process.env.NODE_ENV !== "production") {
+	{
 		const e = errors[error];
 		const msg = isFunction(e) ? e.apply(null, args) : e;
 		throw new Error(`[Immer] ${msg}`);
@@ -438,11 +438,11 @@ for (let key in objectTraps) {
 	};
 }
 arrayTraps.deleteProperty = function(state, prop) {
-	if (process.env.NODE_ENV !== "production" && isNaN(parseInt(prop))) die(13);
+	if (isNaN(parseInt(prop))) die(13);
 	return arrayTraps.set.call(this, state, prop, void 0);
 };
 arrayTraps.set = function(state, prop, value) {
-	if (process.env.NODE_ENV !== "production" && prop !== "length" && isNaN(parseInt(prop))) die(14);
+	if (prop !== "length" && isNaN(parseInt(prop))) die(14);
 	return objectTraps.set.call(this, state[0], prop, value, state[0]);
 };
 function peek(draft, prop) {
@@ -651,7 +651,7 @@ function currentImpl(value) {
 }
 function enablePatches() {
 	const errorOffset = 16;
-	if (process.env.NODE_ENV !== "production") errors.push("Sets cannot have \"replace\" patches.", function(op) {
+	errors.push("Sets cannot have \"replace\" patches.", function(op) {
 		return "Unsupported patch operation: " + op;
 	}, function(path) {
 		return "Cannot apply patch, path doesn't resolve: " + path;

package/dist/{storage-BaLJK6e_.mjs → storage-CTlHUtXI.mjs}

@@ -1,5 +1,4 @@
-import { n as logger } from "./diagnostics-Cg9ycFIM.mjs";
-import { t as createSharedState } from "./shared-state-q9-1EOSX.mjs";
+import { a as logger, t as createSharedState } from "./shared-state-SzgfilJP.mjs";
 import fs from "node:fs";
 import { dirname } from "pathe";
 //#region ../../node_modules/.pnpm/perfect-debounce@2.1.0/node_modules/perfect-debounce/dist/index.mjs

package/dist/structured-clone-qP1sPovr.mjs

@@ -0,0 +1,208 @@
+//#region ../../node_modules/.pnpm/structured-clone-es@2.0.0/node_modules/structured-clone-es/dist/index.mjs
+const env = typeof self === "object" ? self : globalThis;
+function deserializer($, _) {
+	const as = (out, index) => {
+		$.set(index, out);
+		return out;
+	};
+	const unpair = (index) => {
+		if ($.has(index)) return $.get(index);
+		const [type, value] = _[index];
+		switch (type) {
+			case 0:
+			case -1: return as(value, index);
+			case 1: {
+				const arr = as([], index);
+				for (const index of value) arr.push(unpair(index));
+				return arr;
+			}
+			case 2: {
+				const object = as({}, index);
+				for (const [key, index] of value) object[unpair(key)] = unpair(index);
+				return object;
+			}
+			case 3: return as(new Date(value), index);
+			case 4: {
+				const { source, flags } = value;
+				return as(new RegExp(source, flags), index);
+			}
+			case 5: {
+				const map = as(/* @__PURE__ */ new Map(), index);
+				for (const [key, index] of value) map.set(unpair(key), unpair(index));
+				return map;
+			}
+			case 6: {
+				const set = as(/* @__PURE__ */ new Set(), index);
+				for (const index of value) set.add(unpair(index));
+				return set;
+			}
+			case 7: {
+				const { name, message } = value;
+				return as(new env[name](message), index);
+			}
+			case 8: return as(BigInt(value), index);
+			case "BigInt": return as(Object(BigInt(value)), index);
+			case "ArrayBuffer": return as(new Uint8Array(value).buffer, value);
+			case "DataView": {
+				const { buffer } = new Uint8Array(value);
+				return as(new DataView(buffer), value);
+			}
+		}
+		return as(new env[type](value), index);
+	};
+	return unpair;
+}
+/**
+* Returns a deserialized value from a serialized array of Records.
+* @param serialized a previously serialized value.
+*/
+function deserialize(serialized) {
+	return deserializer(/* @__PURE__ */ new Map(), serialized)(0);
+}
+const EMPTY = "";
+const { toString } = {};
+const { keys } = Object;
+function typeOf(value) {
+	const type = typeof value;
+	if (type !== "object" || !value) return [0, type];
+	const asString = toString.call(value).slice(8, -1);
+	switch (asString) {
+		case "Array": return [1, EMPTY];
+		case "Object": return [2, EMPTY];
+		case "Date": return [3, EMPTY];
+		case "RegExp": return [4, EMPTY];
+		case "Map": return [5, EMPTY];
+		case "Set": return [6, EMPTY];
+		case "DataView": return [1, asString];
+	}
+	if (asString.includes("Array")) return [1, asString];
+	if (asString.includes("Error")) return [7, asString];
+	return [2, asString];
+}
+function shouldSkip([TYPE, type]) {
+	return TYPE === 0 && (type === "function" || type === "symbol");
+}
+function serializer(strict, json, $, _) {
+	const as = (out, value) => {
+		const index = _.push(out) - 1;
+		$.set(value, index);
+		return index;
+	};
+	const pair = (value) => {
+		if ($.has(value)) return $.get(value);
+		let [TYPE, type] = typeOf(value);
+		switch (TYPE) {
+			case 0: {
+				let entry = value;
+				switch (type) {
+					case "bigint":
+						TYPE = 8;
+						entry = value.toString();
+						break;
+					case "function":
+					case "symbol":
+						if (strict) throw new TypeError(`unable to serialize ${type}`);
+						entry = null;
+						break;
+					case "undefined": return as([-1], value);
+				}
+				return as([TYPE, entry], value);
+			}
+			case 1: {
+				if (type) {
+					let spread = value;
+					if (type === "DataView") spread = new Uint8Array(value.buffer);
+					else if (type === "ArrayBuffer") spread = new Uint8Array(value);
+					return as([type, [...spread]], value);
+				}
+				const arr = [];
+				const index = as([TYPE, arr], value);
+				for (const entry of value) arr.push(pair(entry));
+				return index;
+			}
+			case 2: {
+				if (type) switch (type) {
+					case "BigInt": return as([type, value.toString()], value);
+					case "Boolean":
+					case "Number":
+					case "String": return as([type, value.valueOf()], value);
+				}
+				if (json && "toJSON" in value) return pair(value.toJSON());
+				const entries = [];
+				const index = as([TYPE, entries], value);
+				for (const key of keys(value)) if (strict || !shouldSkip(typeOf(value[key]))) entries.push([pair(key), pair(value[key])]);
+				return index;
+			}
+			case 3: return as([TYPE, value.toISOString()], value);
+			case 4: {
+				const { source, flags } = value;
+				return as([TYPE, {
+					source,
+					flags
+				}], value);
+			}
+			case 5: {
+				const entries = [];
+				const index = as([TYPE, entries], value);
+				for (const [key, entry] of value) if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry)))) entries.push([pair(key), pair(entry)]);
+				return index;
+			}
+			case 6: {
+				const entries = [];
+				const index = as([TYPE, entries], value);
+				for (const entry of value) if (strict || !shouldSkip(typeOf(entry))) entries.push(pair(entry));
+				return index;
+			}
+		}
+		const { message } = value;
+		return as([TYPE, {
+			name: type,
+			message
+		}], value);
+	};
+	return pair;
+}
+/**
+* Returns an array of serialized Records.
+*/
+function serialize(value, options = {}) {
+	const _ = [];
+	serializer(!(options.json || options.lossy), !!options.json, /* @__PURE__ */ new Map(), _)(value);
+	return _;
+}
+const { parse: $parse, stringify: $stringify } = JSON;
+const options = {
+	json: true,
+	lossy: true
+};
+/**
+* Revive a previously stringified structured clone.
+* @param str previously stringified data as string.
+*/
+function parse(str) {
+	return deserialize($parse(str));
+}
+/**
+* Represent a structured clone value as string.
+* @param any some clone-able value to stringify.
+*/
+function stringify(any) {
+	return $stringify(serialize(any, options));
+}
+//#endregion
+//#region src/utils/structured-clone.ts
+/**
+* Serialize a structured-cloneable value to a single string. Equivalent
+* to `JSON.stringify(structuredCloneSerialize(value))`.
+*/
+function structuredCloneStringify(value) {
+	return stringify(value);
+}
+/**
+* Inverse of {@link structuredCloneStringify}.
+*/
+function structuredCloneParse(value) {
+	return parse(value);
+}
+//#endregion
+export { structuredCloneStringify as n, structuredCloneParse as t };

package/dist/types/index.d.mts

@@ -1,4 +1,4 @@
-import { $ as AgentResourceContent, B as EntriesToObject, G as DevToolsRpcSharedStates, H as Thenable, J as DevToolsDiagnosticsHost, K as DevToolsHost, Q as AgentResource, U as DevToolsRpcClientFunctions, V as PartialWithoutId, W as DevToolsRpcServerFunctions, X as AgentHandle, Y as DevToolsDiagnosticsLogger, Z as AgentManifest, _ as RpcStreamingChannel, a as DevframeRuntime, at as EventEmitter, c as defineDevframe, d as DevToolsNodeContext, et as AgentResourceInput, f as DevToolsNodeRpcSession, g as RpcSharedStateHost, h as RpcSharedStateGetOptions, i as DevframeDeploymentKind, it as DevToolsAgentHostEvents, l as ConnectionMeta, m as RpcFunctionsHost, n as DevframeCliOptions, nt as AgentToolInput, o as DevframeSetupInfo, ot as EventUnsubscribe, p as RpcBroadcastOptions, q as DevToolsDiagnosticsDefinition, r as DevframeDefinition, rt as DevToolsAgentHost, s as DevframeSpaOptions, st as EventsMap, t as DevframeBrowserContext, tt as AgentTool, u as DevToolsCapabilities, v as RpcStreamingChannelOptions, y as RpcStreamingHost, z as DevToolsViewHost } from "../devframe-BXZUBuy6.mjs";
-import { h as RpcFunctionAgentOptions } from "../types-ip8THGH1.mjs";
-import { t as DevToolsNodeRpcSessionMeta } from "../ws-server-kW8RZXTw.mjs";
+import { A as DevToolsDiagnosticsHost, B as DevToolsAgentHostEvents, C as PartialWithoutId, D as DevToolsRpcSharedStates, E as DevToolsRpcServerFunctions, F as AgentResourceContent, H as EventUnsubscribe, I as AgentResourceInput, L as AgentTool, M as AgentHandle, N as AgentManifest, O as DevToolsHost, P as AgentResource, R as AgentToolInput, S as EntriesToObject, T as DevToolsRpcClientFunctions, U as EventsMap, V as EventEmitter, _ as RpcStreamingChannel, a as DevframeRuntime, c as defineDevframe, d as DevToolsNodeContext, f as DevToolsNodeRpcSession, g as RpcSharedStateHost, h as RpcSharedStateGetOptions, i as DevframeDeploymentKind, j as DevToolsDiagnosticsLogger, k as DevToolsDiagnosticsDefinition, l as ConnectionMeta, m as RpcFunctionsHost, n as DevframeCliOptions, o as DevframeSetupInfo, p as RpcBroadcastOptions, r as DevframeDefinition, s as DevframeSpaOptions, t as DevframeBrowserContext, u as DevToolsCapabilities, v as RpcStreamingChannelOptions, w as Thenable, x as DevToolsViewHost, y as RpcStreamingHost, z as DevToolsAgentHost } from "../devframe-C4DNeFuG.mjs";
+import { h as RpcFunctionAgentOptions } from "../types-kKDaD2NT.mjs";
+import { t as DevToolsNodeRpcSessionMeta } from "../ws-server-lHQaafrS.mjs";
 export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, ConnectionMeta, DevToolsAgentHost, DevToolsAgentHostEvents, DevToolsCapabilities, DevToolsDiagnosticsDefinition, DevToolsDiagnosticsHost, DevToolsDiagnosticsLogger, DevToolsHost, DevToolsNodeContext, DevToolsNodeRpcSession, DevToolsNodeRpcSessionMeta, DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, DevToolsRpcSharedStates, DevToolsViewHost, DevframeBrowserContext, DevframeCliOptions, DevframeDefinition, DevframeDeploymentKind, DevframeRuntime, DevframeSetupInfo, DevframeSpaOptions, EntriesToObject, EventEmitter, EventUnsubscribe, EventsMap, PartialWithoutId, RpcBroadcastOptions, RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, RpcStreamingChannel, RpcStreamingChannelOptions, RpcStreamingHost, Thenable, defineDevframe };

package/dist/utils/colors.mjs

@@ -1,2 +1,31 @@
-import { t as colors } from "../colors-DS7k8ljB.mjs";
+//#region src/utils/colors.ts
+function makeColor(open, close) {
+	const o = `\x1B[${open}m`;
+	const c = `\x1B[${close}m`;
+	return ((arg, ...values) => {
+		if (Array.isArray(arg) && "raw" in arg) {
+			const strings = arg;
+			let out = "";
+			for (let i = 0; i < strings.length; i++) {
+				out += strings[i];
+				if (i < values.length) out += String(values[i]);
+			}
+			return `${o}${out}${c}`;
+		}
+		return `${o}${String(arg)}${c}`;
+	});
+}
+const colors = {
+	blue: makeColor(34, 39),
+	cyan: makeColor(36, 39),
+	gray: makeColor(90, 39),
+	green: makeColor(32, 39),
+	red: makeColor(31, 39),
+	yellow: makeColor(33, 39),
+	bold: makeColor(1, 22),
+	dim: makeColor(2, 22),
+	reset: makeColor(0, 0),
+	underline: makeColor(4, 24)
+};
+//#endregion
 export { colors };

package/dist/utils/events.d.mts

@@ -1,4 +1,4 @@
-import { at as EventEmitter, st as EventsMap } from "../devframe-BXZUBuy6.mjs";
+import { T as EventsMap, w as EventEmitter } from "../index-aNunf5Za.mjs";
 
 //#region src/utils/events.d.ts
 /**

package/dist/utils/hash.mjs

@@ -1,2 +1,2 @@
-import { t as hash } from "../hash-CIBte1yS.mjs";
+import { t as hash } from "../hash-bwOD8RgU.mjs";
 export { hash };

package/dist/utils/human-id.d.mts

@@ -1,7 +1,7 @@
 //#region src/utils/human-id.d.ts
 /**
  * Generate a human-readable, lowercase, dash-separated random ID
- * (e.g. `bright-orange-tiger`).
+ * (e.g. `bright-orange-tigers-jump`).
  */
 declare function humanId(): string;
 //#endregion