@jixo/cli 0.23.7 → 0.24.0

package/assets/bundle/google-aistudio.browser.js

@@ -1,3 +1,122 @@
+const isPromiseLike = (value) => value !== null && typeof value?.then === "function";
+const func_remember = /* @__NO_SIDE_EFFECTS__ */ (func, key) => {
+	let result;
+	const once_fn = function(...args) {
+		const newKey = key?.apply(this, args);
+		if (result === void 0 || newKey !== result.key) result = {
+			key: newKey,
+			res: func.apply(this, args)
+		};
+		return result.res;
+	};
+	const once_fn_mix = Object.assign(once_fn, {
+		get source() {
+			return func;
+		},
+		get key() {
+			return result?.key;
+		},
+		get runned() {
+			return result != null;
+		},
+		get returnValue() {
+			return result?.res;
+		},
+		reset() {
+			result = void 0;
+		},
+		rerun(...args) {
+			once_fn_mix.reset();
+			return once_fn_mix(...args);
+		}
+	});
+	Object.defineProperties(once_fn_mix, {
+		source: {
+			value: func,
+			writable: false,
+			configurable: true,
+			enumerable: true
+		},
+		key: {
+			get: () => result?.key,
+			configurable: true,
+			enumerable: true
+		},
+		runned: {
+			get: () => result != null,
+			configurable: true,
+			enumerable: true
+		},
+		returnValue: {
+			get: () => result?.res,
+			configurable: true,
+			enumerable: true
+		}
+	});
+	return once_fn_mix;
+};
+const wrapSuccess = (result) => {
+	return Object.defineProperties([void 0, result], {
+		success: {
+			value: true,
+			writable: false,
+			enumerable: false,
+			configurable: true
+		},
+		result: {
+			value: result,
+			writable: false,
+			enumerable: false,
+			configurable: true
+		},
+		error: {
+			value: void 0,
+			writable: false,
+			enumerable: false,
+			configurable: true
+		}
+	});
+};
+const wrapError = (err, errorParser) => {
+	const error = errorParser ? errorParser(err) : err;
+	return Object.defineProperties([error, void 0], {
+		success: {
+			value: false,
+			writable: false,
+			enumerable: false,
+			configurable: true
+		},
+		result: {
+			value: void 0,
+			writable: false,
+			enumerable: false,
+			configurable: true
+		},
+		error: {
+			value: error,
+			writable: false,
+			enumerable: false,
+			configurable: true
+		}
+	});
+};
+const func_catch = /* @__PURE__ */ Object.assign((fn, errorParser) => {
+	return Object.assign(function() {
+		try {
+			const res = fn.apply(this, arguments);
+			if (isPromiseLike(res)) return res.then((value) => wrapSuccess(value), (err) => wrapError(err, errorParser));
+			return wrapSuccess(res);
+		} catch (err) {
+			return wrapError(err, errorParser);
+		}
+	}, { catchType(errorParser$1) {
+		return func_catch(fn, errorParser$1);
+	} });
+}, {
+	wrapSuccess,
+	wrapError
+});
+const effect_symbol = Symbol.for("effect");
 let rootDirHandle;
 const prepareDirHandle = async () => {
 	if (rootDirHandle) return rootDirHandle;
@@ -21,6 +140,117 @@ const prepareDirHandle = async () => {
 		throw e;
 	}
 };
+const getEasyFs = /* @__PURE__ */ func_remember(async () => {
+	const [error, dirHandle] = await func_catch(prepareDirHandle)();
+	if (!dirHandle) {
+		getEasyFs.reset();
+		throw error;
+	}
+	const getHandle = async (path, { create = false } = {}) => {
+		let curr = dirHandle;
+		const parts = path.split("/").filter(Boolean);
+		const last = parts.at(-1);
+		for (let i = 0; i < parts.length - 1; i++) curr = await curr.getDirectoryHandle(parts[i], { create });
+		return {
+			parent: curr,
+			name: last,
+			async getFile() {
+				if (!last) throw new Error("No file name");
+				return curr.getFileHandle(last, { create });
+			},
+			async getDir() {
+				if (!last) return curr;
+				return curr.getDirectoryHandle(last, { create });
+			}
+		};
+	};
+	const writeFile = async (filePath, data, opts) => {
+		const { getFile } = await getHandle(filePath, { create: true });
+		const handle = await getFile();
+		const w = await handle.createWritable();
+		if (!opts?.append) await w.truncate(0);
+		await w.write(data);
+		await w.close();
+	};
+	const createWriteStream = async (filePath) => {
+		const { getFile } = await getHandle(filePath, { create: true });
+		const handle = await getFile();
+		return handle.createWritable();
+	};
+	const readFileText = async (filePath) => {
+		const { getFile } = await getHandle(filePath);
+		const file = await (await getFile()).getFile();
+		return file.text();
+	};
+	const readFileBinary = async (filePath) => {
+		const { getFile } = await getHandle(filePath);
+		const file = await (await getFile()).getFile();
+		return file.bytes();
+	};
+	const createReadStream = async (filePath) => {
+		const { getFile } = await getHandle(filePath);
+		const file = await (await getFile()).getFile();
+		return file.stream();
+	};
+	const readdir = async (dirPath) => {
+		const { getDir } = await getHandle(dirPath);
+		const dir = await getDir();
+		return Array.fromAsync(dir.keys());
+	};
+	const mkdir = async (dirPath, opts) => {
+		const parts = dirPath.split("/").filter(Boolean);
+		let curr = dirHandle;
+		for (const segment of parts) {
+			curr = await curr.getDirectoryHandle(segment, { create: true });
+			if (!opts?.recursive) break;
+		}
+	};
+	const exists = async (path) => {
+		try {
+			await getHandle(path);
+			return true;
+		} catch {
+			return false;
+		}
+	};
+	const stat = async (path) => {
+		const { getFile, getDir } = await getHandle(path);
+		try {
+			const h = await getFile();
+			const f = await h.getFile();
+			return {
+				isFile: true,
+				size: f.size,
+				lastModified: f.lastModified
+			};
+		} catch {
+			await getDir();
+			return { isFile: false };
+		}
+	};
+	const rm = async (path, opts) => {
+		try {
+			const { parent, name } = await getHandle(path);
+			if (!name) throw new Error("Invalid path");
+			await parent.removeEntry(name, { recursive: opts?.recursive });
+			return true;
+		} catch {
+			return false;
+		}
+	};
+	return {
+		writeFile,
+		createWriteStream,
+		readFileText,
+		readFileBinary,
+		createReadStream,
+		readdir,
+		mkdir,
+		exists,
+		stat,
+		rm
+	};
+});
 const styles = {
 	header: "color: #4CAF50; font-size: 18px; font-weight: bold; border-bottom: 2px solid #4CAF50; padding-bottom: 5px;",
 	info: "color: #2196F3; font-style: italic;",
@@ -94,7 +324,7 @@ const fillFunctionCall = async () => {
 	buttonEle.click();
 	await rootDirHandle$1.removeEntry(callTaskname);
 };
-const syncInput = async (fps = 2) => {
+const syncInput = async (fps = 3) => {
 	(async () => {
 		while (true) {
 			await fillFunctionCall();