@auspex-ai/next 0.0.0-stage → 1.4.1

package/dist/transform-Dc5diC_P.cjs

@@ -0,0 +1,441 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let node_crypto = require("node:crypto");
+let node_fs = require("node:fs");
+let _babel_parser = require("@babel/parser");
+require("magic-string");
+//#region ../build-names/src/element-ref.ts
+const ALPHABET = "abcdefghijklmnopqrstuvwxyz234567";
+const REF_LENGTH = 12;
+/** RFC 4648 の base32 を小文字・パディング無しにしたもの */
+function base32(bytes) {
+	let out = "";
+	let bits = 0;
+	let acc = 0;
+	for (const b of bytes) {
+		acc = acc << 8 | b;
+		bits += 8;
+		while (bits >= 5) {
+			out += ALPHABET[acc >>> bits - 5 & 31];
+			bits -= 5;
+		}
+		acc &= (1 << bits) - 1;
+	}
+	if (bits > 0) out += ALPHABET[acc << 5 - bits & 31];
+	return out;
+}
+/** 名前の参照(`^[a-z2-7]{12}$`)。ビルド鍵は UTF-8 のバイト列として HMAC の鍵にする */
+function nameRef(key, name, kind) {
+	return base32((0, node_crypto.createHmac)("sha256", Buffer.from(key, "utf8")).update(`${kind}:${name}`).digest()).slice(0, REF_LENGTH);
+}
+/** sha256(ビルド鍵)の先頭 16 文字(16 進)。秘密ではなく(先頭 64 bit から鍵は戻せない)、キャッシュやオプションに残ってよい */
+function keyIdOf(key) {
+	return (0, node_crypto.createHash)("sha256").update(key, "utf8").digest("hex").slice(0, 16);
+}
+//#endregion
+//#region ../build-names/src/log.ts
+const WARNED = Symbol.for("auspex.warned");
+const PREFIX = "[auspex]";
+const consoleLogger = {
+	info: (m) => console.log(`${PREFIX} ${m}`),
+	warn: (m) => console.warn(`${PREFIX} ${m}`)
+};
+/** `id` の警告を、このプロセスでまだ出していなければ出す(出したら true) */
+function warnOnce(id, message, logger = consoleLogger) {
+	const g = globalThis;
+	const seen = g[WARNED] ?? /* @__PURE__ */ new Set();
+	g[WARNED] = seen;
+	if (seen.has(id)) return false;
+	seen.add(id);
+	logger.warn(message);
+	return true;
+}
+//#endregion
+//#region ../build-names/src/icon-name/shared.ts
+let downgraded = 0;
+let exitHooked = false;
+/** 参照を書くはずだったのに 'strip' に落ちたモジュールの数を、プロセスの終わり(最善努力)にログへ出す */
+function countDowngrade() {
+	downgraded++;
+	if (exitHooked) return;
+	exitHooked = true;
+	process.once("exit", () => {
+		console.warn(`[auspex] ビルド鍵が無い、または withAuspex() が見た鍵と違うため、参照を書かなかったモジュール: ${downgraded} 件`);
+	});
+}
+/** 断片を原子的に書く(一時ファイル + rename)。書けなくてもビルドは続ける */
+function writeFragment(dir, file, fragment) {
+	const name = `${(0, node_crypto.createHash)("sha256").update(file).digest("hex").slice(0, 16)}.json`;
+	const target = node_path.default.join(dir, name);
+	const tmp = `${target}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+	try {
+		(0, node_fs.mkdirSync)(dir, { recursive: true });
+		(0, node_fs.writeFileSync)(tmp, JSON.stringify(fragment));
+		(0, node_fs.renameSync)(tmp, target);
+	} catch (e) {
+		warnOnce("fragment-write", `[auspex] 名前の断片を書けなかった(${dir}: ${e.message})。この名前は登録されない`);
+	}
+}
+/**
+* 参照を書くモードのとき、鍵を確かめて参照の計算を返す。鍵が無い・`options.keyId` と違うときは null
+* (古い参照を書かず 'strip' に落ちる。警告は 1 回、数はプロセスの終わりに出す)。'strip' のモードは null(警告なし)
+*/
+function refOfFromEnv(options) {
+	if (options.elementNames !== "refs") return null;
+	const key = process.env.AUSPEX_BUILD_KEY;
+	if (key && (options.keyId === void 0 || keyIdOf(key) === options.keyId)) return (name, kind) => nameRef(key, name, kind);
+	countDowngrade();
+	warnOnce("loader-key-mismatch", key ? "[auspex] AUSPEX_BUILD_KEY が withAuspex() の読み込み時と違う(next.config を読んだ後に変わった)ため、参照を書かない" : "[auspex] AUSPEX_BUILD_KEY が読めないため、参照を書かない(ワーカーに環境変数が届いていない可能性がある)");
+	return null;
+}
+//#endregion
+//#region ../build-names/src/icon-name/transform.ts
+/** 書く属性。@auspex-ai/core の ICON_REF_ATTR(読む側)と同じ値(test/ で一致を確かめる) */
+const ICON_REF_ATTR = "data-auspex-icon-ref";
+/** #12 の旧属性(平文の名前)。今は書かず、手書きのものを消すだけ */
+const LEGACY_ICON_ATTR = "data-auspex-icon";
+const ATTR = ICON_REF_ATTR;
+/** 自分の名前を使わない汎用名(名前は呼び出し側の props か、外から渡された値で決まる) */
+const GENERIC = /^(Icon|Icons|IconBase|BaseIcon|Svg|SvgIcon|IconWrapper|Glyph|StyledSvg)$/;
+/** アイコンらしい名前(呼び出し側の名前 props を拾う対象、根に返すと自分の名前を渡す対象) */
+const ICONISH = /Icon|Svg|Glyph/;
+/** 名前を表す props。type は汎用名の要素だけ(<Button type="submit"> 等を拾わないため) */
+const NAME_PROPS = [
+	"name",
+	"icon",
+	"iconName",
+	"glyph"
+];
+const NAME_PROPS_GENERIC = [...NAME_PROPS, "type"];
+const SKIP_KEYS = /* @__PURE__ */ new Set([
+	"loc",
+	"start",
+	"end",
+	"extra",
+	"range",
+	"leadingComments",
+	"trailingComments",
+	"innerComments"
+]);
+/** AST を深さ優先でたどる。stopAtFunctions なら入れ子の関数の中には入らない */
+function walk(node, visit, stopAtFunctions = false, root = true) {
+	visit(node);
+	if (stopAtFunctions && !root && /Function|ClassMethod/.test(node.type)) return;
+	for (const key of Object.keys(node)) {
+		if (SKIP_KEYS.has(key)) continue;
+		const v = node[key];
+		if (Array.isArray(v)) {
+			for (const c of v) if (c && typeof c.type === "string") walk(c, visit, stopAtFunctions, false);
+		} else if (v && typeof v.type === "string") walk(v, visit, stopAtFunctions, false);
+	}
+}
+function calleeName(c) {
+	if (c.type === "Identifier") return c.name;
+	if (c.type === "MemberExpression" && c.property.type === "Identifier") return c.property.name;
+	return "";
+}
+/** forwardRef(...) / memo(...) / 型注釈の包みを剥がして関数を取り出す */
+function unwrapFn(e) {
+	let n = e;
+	while (n && (n.type === "TSAsExpression" || n.type === "TSSatisfiesExpression" || n.type === "ParenthesizedExpression")) n = n.expression;
+	if (!n) return null;
+	if (n.type === "ArrowFunctionExpression" || n.type === "FunctionExpression") return n;
+	if (n.type === "CallExpression" && ["forwardRef", "memo"].includes(calleeName(n.callee))) {
+		const [arg] = n.arguments;
+		return arg && arg.type !== "SpreadElement" && arg.type !== "ArgumentPlaceholder" ? unwrapFn(arg) : null;
+	}
+	return null;
+}
+function tagName(o) {
+	if (o.name.type === "JSXIdentifier") return o.name.name;
+	if (o.name.type === "JSXMemberExpression") return o.name.property.name;
+	return "";
+}
+/** ビルド時に値が決まる文字列: リテラル / 式を含まないテンプレートリテラル / 両辺がそうである条件式 */
+function isStaticString(e) {
+	if (!e) return false;
+	switch (e.type) {
+		case "StringLiteral": return true;
+		case "TemplateLiteral": return e.expressions.length === 0;
+		case "ConditionalExpression": return isStaticString(e.consequent) && isStaticString(e.alternate);
+		case "ParenthesizedExpression": return isStaticString(e.expression);
+		default: return false;
+	}
+}
+/** アイコンらしい要素で、名前を表す props が静的な文字列ならその式を返す */
+function staticNameProp(o) {
+	const tag = tagName(o);
+	if (!/^[A-Z]/.test(tag) || !ICONISH.test(tag)) return null;
+	const props = GENERIC.test(tag) ? NAME_PROPS_GENERIC : NAME_PROPS;
+	for (const a of o.attributes) {
+		if (a.type !== "JSXAttribute" || a.name.type !== "JSXIdentifier" || !props.includes(a.name.name) || !a.value) continue;
+		const v = a.value.type === "JSXExpressionContainer" ? a.value.expression : a.value;
+		if (isStaticString(v)) return v;
+	}
+	return null;
+}
+/** 名前を表す props を受け取るコンポーネントは汎用とみなす */
+function takesNameProp(fn) {
+	const [p0] = fn.params;
+	return p0?.type === "ObjectPattern" && p0.properties.some((p) => p.type === "ObjectProperty" && p.key.type === "Identifier" && NAME_PROPS_GENERIC.includes(p.key.name));
+}
+function collectComponents(program, file) {
+	const comps = [];
+	const base = node_path.default.basename(file).replace(/\.[^.]+$/, "");
+	walk(program, (n) => {
+		if (n.type === "FunctionDeclaration" && n.id) comps.push({
+			fn: n,
+			name: n.id.name,
+			isClass: false
+		});
+		else if (n.type === "VariableDeclarator" && n.id.type === "Identifier") {
+			const fn = unwrapFn(n.init);
+			if (fn) comps.push({
+				fn,
+				name: n.id.name,
+				isClass: false
+			});
+		} else if (n.type === "ObjectProperty" && !n.computed) {
+			const fn = unwrapFn(n.value);
+			const key = n.key.type === "Identifier" ? n.key.name : n.key.type === "StringLiteral" ? n.key.value : null;
+			if (fn && key) comps.push({
+				fn,
+				name: key,
+				isClass: false
+			});
+		} else if (n.type === "ExportDefaultDeclaration") {
+			const d = n.declaration;
+			const fn = d.type === "FunctionDeclaration" ? d.id ? null : d : unwrapFn(d);
+			if (fn) comps.push({
+				fn,
+				name: base,
+				isClass: false
+			});
+		} else if (n.type === "ClassDeclaration" && n.id) {
+			const render = n.body.body.find((m) => m.type === "ClassMethod" && m.key.type === "Identifier" && m.key.name === "render");
+			if (render) comps.push({
+				fn: render,
+				name: n.id.name,
+				isClass: true
+			});
+		}
+	});
+	return comps;
+}
+/** コンポーネントが返す根の要素(return / 式本体 / 条件式の両辺 / && の右辺 / フラグメントの最初の要素) */
+function rootsOf(fn) {
+	const roots = [];
+	const add = (e) => {
+		let n = e;
+		while (n && (n.type === "ParenthesizedExpression" || n.type === "TSAsExpression")) n = n.expression;
+		if (!n) return;
+		if (n.type === "JSXElement") roots.push({ jsx: n.openingElement });
+		else if (n.type === "ConditionalExpression") {
+			add(n.consequent);
+			add(n.alternate);
+		} else if (n.type === "LogicalExpression") add(n.right);
+		else if (n.type === "JSXFragment") {
+			const first = n.children.find((c) => c.type === "JSXElement");
+			if (first) roots.push({ jsx: first.openingElement });
+		} else if (n.type === "CallExpression" && [
+			"createElement",
+			"jsx",
+			"jsxs",
+			"_jsx",
+			"_jsxs"
+		].includes(calleeName(n.callee)) && n.arguments[0]?.type === "StringLiteral" && n.arguments[0].value === "svg") roots.push({ call: n });
+	};
+	if (fn.body.type !== "BlockStatement") add(fn.body);
+	else walk(fn.body, (n) => n.type === "ReturnStatement" && add(n.argument), true);
+	return roots;
+}
+const startOf = (n) => n.start ?? 0;
+const endOf = (n) => n.end ?? 0;
+/** JS/TS のソースを解析する(解析できなければ null。ビルドはバンドラ側のエラーに任せる) */
+function parseSource(source, file) {
+	const ext = node_path.default.extname(file);
+	try {
+		return (0, _babel_parser.parse)(source, {
+			sourceType: "module",
+			plugins: ext === ".ts" ? ["typescript"] : ext === ".tsx" ? ["typescript", "jsx"] : ["jsx"]
+		}).program;
+	} catch {
+		return null;
+	}
+}
+/** アイコンに関係しうるファイルか(解析する前の絞り込み) */
+function mayHaveIcons(source) {
+	return /svg|Icon|Glyph/.test(source);
+}
+/**
+* アイコン名の参照の書き込みを `s` に積む(要素名の変換と同じ MagicString に積めるよう分けている。手書きの属性の削除は
+* 先に stripHandWritten で積む)。参照を書いた名前を返す
+*/
+function applyIconNames(program, source, file, s, refOf) {
+	const touched = /* @__PURE__ */ new Set();
+	const written = /* @__PURE__ */ new Set();
+	const refLiteral = (name) => {
+		written.add(name);
+		return JSON.stringify(refOf(name));
+	};
+	/** 静的な文字列の式を、各リテラルを参照に置き換えた式にする(名前は written に残る) */
+	const refExpr = (e) => {
+		switch (e.type) {
+			case "StringLiteral": return refLiteral(e.value);
+			case "TemplateLiteral": return refLiteral(e.quasis[0]?.value.cooked ?? "");
+			case "ConditionalExpression": return `${source.slice(startOf(e.test), endOf(e.test))} ? ${refExpr(e.consequent)} : ${refExpr(e.alternate)}`;
+			case "ParenthesizedExpression": return `(${refExpr(e.expression)})`;
+			default: return "undefined";
+		}
+	};
+	for (const { fn, name, isClass } of collectComponents(program, file)) {
+		const roots = rootsOf(fn);
+		const svgRoots = roots.flatMap((r) => "jsx" in r && tagName(r.jsx) === "svg" ? [r.jsx] : []);
+		const callRoots = roots.flatMap((r) => "call" in r ? [r.call] : []);
+		const iconishRoots = roots.flatMap((r) => "jsx" in r && /^[A-Z]/.test(tagName(r.jsx)) && ICONISH.test(tagName(r.jsx)) ? [r.jsx] : []);
+		if (!svgRoots.length && !callRoots.length && !iconishRoots.length) continue;
+		const generic = GENERIC.test(name) || !isClass && takesNameProp(fn);
+		let passed = null;
+		const [p0] = fn.params;
+		if (isClass) passed = `this.props?.[${JSON.stringify(ATTR)}]`;
+		else if (p0?.type === "ObjectPattern") {
+			s.appendRight(startOf(p0) + 1, ` ${JSON.stringify(ATTR)}: __auspexIcon,`);
+			passed = "__auspexIcon";
+		} else if (p0?.type === "Identifier") passed = `${p0.name}?.[${JSON.stringify(ATTR)}]`;
+		let cached;
+		const iconValue = () => {
+			if (cached === void 0) {
+				const own = generic ? "undefined" : refLiteral(name);
+				cached = passed ? `${passed} ?? ${own}` : own;
+			}
+			return cached;
+		};
+		for (const o of svgRoots) {
+			if (touched.has(o)) continue;
+			s.appendLeft(endOf(o.name), ` ${ATTR}={${iconValue()}}`);
+			touched.add(o);
+		}
+		for (const call of callRoots) {
+			const props = call.arguments[1];
+			const entry = `${JSON.stringify(ATTR)}: ${iconValue()}`;
+			if (!props) {
+				const tagArg = call.arguments[0];
+				if (tagArg) s.appendLeft(endOf(tagArg), `, { ${entry} }`);
+			} else if (props.type === "NullLiteral") s.overwrite(startOf(props), endOf(props), `{ ${entry} }`);
+			else if (props.type === "ObjectExpression") s.appendRight(startOf(props) + 1, ` ${entry},`);
+			else {
+				s.prependLeft(startOf(props), "{ ...");
+				s.appendRight(endOf(props), `, ${entry} }`);
+			}
+		}
+		for (const o of iconishRoots) {
+			if (touched.has(o) || staticNameProp(o)) continue;
+			if (generic && !passed) continue;
+			s.appendLeft(endOf(o.name), ` ${ATTR}={${generic ? passed : iconValue()}}`);
+			touched.add(o);
+		}
+	}
+	walk(program, (n) => {
+		if (n.type !== "JSXOpeningElement" || touched.has(n)) return;
+		const v = staticNameProp(n);
+		if (!v) return;
+		s.appendLeft(endOf(n.name), ` ${ATTR}={${refExpr(v)}}`);
+		touched.add(n);
+	});
+	return [...written];
+}
+/** .svg のソースから手書きの data-auspex-icon・data-auspex-icon-ref を消す(SVGR が props にして HTML に載せるため) */
+const HAND_WRITTEN_SVG_ATTR = /\s+data-auspex-icon(?:-ref)?\s*=\s*(?:"[^"]*"|'[^']*')/g;
+/**
+* .svg ファイル(SVGR の前段)。手書きの属性を消し、`refOf` があれば根の <svg> にファイル名の参照を書く
+* (strip のみのときは書かない)。変更が無ければ null。書いた名前は `name`
+*/
+function transformSvgFile(source, file, refOf) {
+	const stripped = source.replace(HAND_WRITTEN_SVG_ATTR, "");
+	const name = node_path.default.basename(file).replace(/\.svg$/i, "").replace(/[^A-Za-z0-9_:-]/g, "-").slice(0, 64);
+	if (!refOf || !name || !/<svg\b/.test(stripped)) return stripped === source ? null : {
+		code: stripped,
+		name: null
+	};
+	return {
+		code: stripped.replace(/<svg\b/, `<svg ${ATTR}="${refOf(name)}"`),
+		name
+	};
+}
+//#endregion
+Object.defineProperty(exports, "ICON_REF_ATTR", {
+	enumerable: true,
+	get: function() {
+		return ICON_REF_ATTR;
+	}
+});
+Object.defineProperty(exports, "LEGACY_ICON_ATTR", {
+	enumerable: true,
+	get: function() {
+		return LEGACY_ICON_ATTR;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "applyIconNames", {
+	enumerable: true,
+	get: function() {
+		return applyIconNames;
+	}
+});
+Object.defineProperty(exports, "mayHaveIcons", {
+	enumerable: true,
+	get: function() {
+		return mayHaveIcons;
+	}
+});
+Object.defineProperty(exports, "parseSource", {
+	enumerable: true,
+	get: function() {
+		return parseSource;
+	}
+});
+Object.defineProperty(exports, "refOfFromEnv", {
+	enumerable: true,
+	get: function() {
+		return refOfFromEnv;
+	}
+});
+Object.defineProperty(exports, "transformSvgFile", {
+	enumerable: true,
+	get: function() {
+		return transformSvgFile;
+	}
+});
+Object.defineProperty(exports, "writeFragment", {
+	enumerable: true,
+	get: function() {
+		return writeFragment;
+	}
+});

package/package.json

@@ -1,6 +1,79 @@
 {
   "name": "@auspex-ai/next",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.4.1",
+  "type": "module",
+  "sideEffects": false,
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NA-LUDENS/auspex.git",
+    "directory": "packages/next"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./config": {
+      "types": "./dist/config.d.mts",
+      "import": "./dist/config.mjs",
+      "require": "./dist/config.cjs"
+    }
+  },
+  "bin": {
+    "auspex-register-names": "./dist/register-names-cli.mjs"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "dependencies": {
+    "@auspex-ai/core": "^1.4.1",
+    "@babel/parser": "^7.29.8",
+    "magic-string": "^1.4.1"
+  },
+  "peerDependencies": {
+    "next": ">=14",
+    "react": ">=18",
+    "google-auth-library": ">=9"
+  },
+  "devDependencies": {
+    "@auspex-ai/build-names": "0.0.0",
+    "@babel/types": "^7.29.8",
+    "@svgr/webpack": "^8.1.0",
+    "@types/node": "^22.20.3",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "google-auth-library": "^11.2.0",
+    "lucide-react": "^1.46.0",
+    "next": "^16.4.1",
+    "playwright": "^1.63.0",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "rolldown": "^1.2.8",
+    "styled-components": "^6.5.3",
+    "tsdown": "^0.23.0",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.1"
+  },
+  "peerDependenciesMeta": {
+    "google-auth-library": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "lint": "biome check .",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --project unit",
+    "test:integration": "vitest run --project integration",
+    "test:acceptance": "vitest run --project acceptance"
+  }
 }