@jixo/cli 0.23.7 → 0.24.1

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

@@ -1,3 +1,213 @@
+const obj_assign_props = /* @__NO_SIDE_EFFECTS__ */ (a, b) => {
+	const b_props = Object.getOwnPropertyDescriptors(b);
+	Object.defineProperties(a, b_props);
+	return a;
+};
+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");
+const timmers = {
+	timeout: (ms) => {
+		return (cb) => {
+			const ti = setTimeout(cb, ms);
+			return () => clearTimeout(ti);
+		};
+	},
+	raf: ((cb) => {
+		const ti = requestAnimationFrame(cb);
+		return () => cancelAnimationFrame(ti);
+	}),
+	microtask: ((cb) => {
+		let cancel = false;
+		queueMicrotask(() => {
+			if (cancel) return;
+			cb();
+		});
+		return () => {
+			cancel = true;
+		};
+	}),
+	eventTarget: (target, eventType, filter) => {
+		return (resolve) => {
+			let cb;
+			if (typeof filter === "function") {
+				cb = (event) => {
+					if (filter(event)) {
+						resolve(event);
+						target.removeEventListener(eventType, cb);
+					}
+				};
+				target.addEventListener(eventType, cb);
+			} else {
+				cb = resolve;
+				target.addEventListener(eventType, cb, { once: true });
+			}
+			return () => target.removeEventListener(eventType, cb);
+		};
+	},
+	from: (ms) => {
+		return typeof ms === "number" ? ms <= 0 ? timmers.microtask : timmers.timeout(ms) : ms;
+	}
+};
+const func_throttle = (fn, wait = 0, options = {}) => {
+	const timmer = timmers.from(wait);
+	let clear;
+	let jobs = [];
+	let target;
+	return /* @__PURE__ */ obj_assign_props(function throttled(...args) {
+		const job = Promise.withResolvers();
+		if (clear == null) {
+			clear = timmer(target = async () => {
+				target = void 0;
+				if (!options.waitPromise) clear = void 0;
+				const res = await func_catch(() => fn.apply(this, args))();
+				if (options.waitPromise) clear = void 0;
+				if (res.success) for (const job$1 of jobs) job$1.resolve(res.result);
+				else for (const job$1 of jobs) job$1.reject(res.error);
+				jobs = [];
+			}, (reason) => {
+				for (const job$1 of jobs) job$1.reject(reason);
+			});
+			if (options.before) (async () => {
+				const res = await func_catch(() => fn.apply(this, args))();
+				if (res.success) job.resolve(res.result);
+				else job.reject(res.error);
+			})();
+			else jobs.push(job);
+		} else jobs.push(job);
+		return job.promise;
+	}, {
+		get isPending() {
+			return clear != null;
+		},
+		cancel() {
+			clear?.();
+			clear = void 0;
+		},
+		source: fn,
+		flush() {
+			clear?.();
+			clear = void 0;
+			target?.();
+		}
+	});
+};
 let rootDirHandle;
 const prepareDirHandle = async () => {
 	if (rootDirHandle) return rootDirHandle;
@@ -21,6 +231,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;",
@@ -36,19 +357,6 @@ const arrayFromAsync = async (iter) => {
 };
 const getTargetNamespace = () => location.pathname.split("/").at(-1);
 const delay = (ms) => new Promise((cb) => setTimeout(cb, ms));
-const aFollowedByB = (el, aSelector, bSelector, cb) => {
-	const run = () => {
-		console.log("QAQ", el);
-		for (const bEle of el.querySelectorAll(`:scope > ${aSelector} + ${bSelector}`)) {
-			const aEle = bEle.previousElementSibling;
-			cb(aEle, bEle);
-		}
-	};
-	const mo = new MutationObserver(run);
-	mo.observe(el, { childList: true });
-	run();
-	return () => mo.disconnect();
-};
 const $ = document.querySelector.bind(document);
 const $$ = document.querySelectorAll.bind(document);
 const fillFunctionCall = async () => {
@@ -94,7 +402,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();
@@ -102,78 +410,32 @@ const syncInput = async (fps = 2) => {
 		}
 	})();
 };
-const syncOutput = () => {
-	const styleEle = document.createElement("style");
-	const headEle = $("head");
-	const css = String.raw;
-	styleEle.innerText = css`
-    .cdk-global-overlay-wrapper:has(.get-code-dialog) {
-      display: none;
-    }
-    button[aria-label="Get code"] {
-      pointer-events: none;
-    }
-  `.replaceAll("\n", "");
-	headEle.appendChild(styleEle);
-	const findCdkOverlayContainer = () => $(".cdk-overlay-container");
-	const cdkOverlayTaskId = Symbol.for("cdk-overlay-style-hooks");
-	if (!window[cdkOverlayTaskId]) {
-		let cdkOverlayContainer;
-		let off = () => {};
-		window[cdkOverlayTaskId] = setInterval(() => {
-			const newCdkOverlayContainer = findCdkOverlayContainer();
-			if (newCdkOverlayContainer !== cdkOverlayContainer && newCdkOverlayContainer) {
-				off();
-				off = aFollowedByB(cdkOverlayContainer = newCdkOverlayContainer, ".cdk-overlay-backdrop", ".cdk-global-overlay-wrapper:has(.get-code-dialog)", (cdkOverlayBackdropEle) => {
-					if (cdkOverlayBackdropEle.style.display !== "none") {
-						console.log("%c隐藏遮罩元素", styles.warn, cdkOverlayBackdropEle);
-						cdkOverlayBackdropEle.style.display = "none";
-					}
-				});
-			}
-		}, 1e3);
-	}
-	const findMustacheKey = () => {
-		for (const key in default_MakerSuite) {
-			const render = default_MakerSuite[key]?.render;
-			if (render && typeof render === "function") return key;
-		}
+const syncOutput = async () => {
+	const onChange = func_throttle(runFileCreation, 200, {
+		before: true,
+		waitPromise: true
+	});
+	const arr_push = Array.prototype[Symbol.for("arr_push")] || Array.prototype.push;
+	Array.prototype[Symbol.for("arr_push")] = arr_push;
+	Array.prototype.push = function push(...args) {
+		const a = args[0];
+		if (a && Object.getPrototypeOf(a) === Object.prototype && a.role && a.id && typeof a.text === "string") onChange(this);
+		return arr_push.apply(this, args);
 	};
-	const waitMustacheKey = async () => {
-		while (true) {
-			const key = findMustacheKey();
-			if (key) return key;
-			await new Promise((c) => setTimeout(c, 200));
+	const findInput = () => $(`textarea[aria-label="Start typing a prompt"]`);
+	while (!started) {
+		const input = findInput();
+		if (input) {
+			input.dispatchEvent(new Event("input"));
+			started = true;
 		}
-	};
-	async function startInject() {
-		const key = await waitMustacheKey();
-		const _render = default_MakerSuite[key].render;
-		default_MakerSuite[key].render = (...args) => {
-			const b = args[1];
-			runFileCreation(b);
-			return "";
-		};
-		const findInput = () => $(`textarea[aria-label="Start typing a prompt"]`);
-		findInput()?.dispatchEvent(new Event("input"));
+		await delay(300);
 	}
-	if (!$(".cdk-overlay-container:has(.get-code-dialog)")) {
-		const findBtn = () => $(`button[aria-label="Get code"]`);
-		const waitBtn = async () => {
-			while (true) {
-				const btn = findBtn();
-				if (btn) return btn;
-				await delay(200);
-			}
-		};
-		waitBtn().then((getCodeButtonEle) => {
-			getCodeButtonEle.click();
-			requestAnimationFrame(startInject);
-		});
-	} else startInject();
 };
+let started = false;
 let writting = false;
 async function runFileCreation(b, targetFilename = getTargetNamespace() + ".contents.json") {
+	started = true;
 	if (writting) return;
 	writting = true;
 	try {