@ptdgrp/typedgql 1.0.0-beta.8

package/dist/index.cjs

@@ -0,0 +1,911 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/runtime/types.ts
+const __runtime = Symbol("__selection_runtime");
+function runtimeOf(selection) {
+	return selection[__runtime];
+}
+var StringValue = class {
+	constructor(value, quotationMarks = true) {
+		this.value = value;
+		this.quotationMarks = quotationMarks;
+	}
+};
+const __fragment_spread = Symbol("__fragment_spread");
+var FragmentSpread = class {
+	[__fragment_spread] = true;
+	constructor(name, selection) {
+		this.name = name;
+		this.selection = selection;
+	}
+};
+var FragmentRef = class extends FragmentSpread {
+	constructor(name, selection) {
+		super(name, selection);
+	}
+};
+
+//#endregion
+//#region src/runtime/schema.ts
+const SCHEMA_TYPE_REGISTRY = /* @__PURE__ */ new Map();
+const SCHEMA_TYPE_FACTORY_REGISTRY = /* @__PURE__ */ new Map();
+const SCHEMA_TYPE_RESOLVING = /* @__PURE__ */ new Set();
+const resolveRegisteredSchemaType = (typeName) => {
+	const registered = SCHEMA_TYPE_REGISTRY.get(typeName);
+	if (registered) return registered;
+	const factory = SCHEMA_TYPE_FACTORY_REGISTRY.get(typeName);
+	if (!factory) return;
+	if (SCHEMA_TYPE_RESOLVING.has(typeName)) throw new Error(`Circular schema factory resolution detected for "${typeName}"`);
+	SCHEMA_TYPE_RESOLVING.add(typeName);
+	try {
+		registerSchemaType(factory());
+	} finally {
+		SCHEMA_TYPE_RESOLVING.delete(typeName);
+	}
+	return SCHEMA_TYPE_REGISTRY.get(typeName);
+};
+const registerSchemaTypeFactory = (typeName, factory) => {
+	if (!SCHEMA_TYPE_FACTORY_REGISTRY.has(typeName)) SCHEMA_TYPE_FACTORY_REGISTRY.set(typeName, factory);
+};
+const createSchemaType = (name, category, superTypes, declaredFields) => {
+	const declaredFieldMap = /* @__PURE__ */ new Map();
+	for (const desc of declaredFields) if (typeof desc === "string") declaredFieldMap.set(desc, buildField(desc, "SCALAR", /* @__PURE__ */ new Map()));
+	else {
+		const argMap = /* @__PURE__ */ new Map();
+		if (desc.argGraphQLTypeMap) for (const k in desc.argGraphQLTypeMap) argMap.set(k, desc.argGraphQLTypeMap[k]);
+		declaredFieldMap.set(desc.name, buildField(desc.name, desc.category, argMap, desc.targetTypeName, desc.undefinable));
+	}
+	let _fields;
+	const result = {
+		name,
+		category,
+		interfaces: superTypes,
+		ownFields: declaredFieldMap,
+		get fields() {
+			if (!_fields) _fields = superTypes.length === 0 ? declaredFieldMap : collectFields(result);
+			return _fields;
+		}
+	};
+	registerSchemaType(result);
+	return result;
+};
+const buildField = (name, category, argGraphQLTypeMap, targetTypeName, undefinable) => {
+	const isPlural = category === "LIST";
+	const isAssociation = category === "REFERENCE" || isPlural;
+	return {
+		name,
+		category,
+		argGraphQLTypeMap,
+		targetTypeName,
+		isPlural,
+		isAssociation,
+		isFunction: argGraphQLTypeMap.size !== 0 || isAssociation || targetTypeName !== void 0,
+		isUndefinable: undefinable ?? false
+	};
+};
+const collectFields = (type) => {
+	const result = /* @__PURE__ */ new Map();
+	_collect(type, result);
+	return result;
+};
+const _collect = (type, out) => {
+	for (const [name, field] of type.ownFields) out.set(name, field);
+	for (const superType of type.interfaces) _collect(superType, out);
+};
+const registerSchemaType = (type) => {
+	const existing = SCHEMA_TYPE_REGISTRY.get(type.name);
+	if (!existing) {
+		SCHEMA_TYPE_REGISTRY.set(type.name, type);
+		return;
+	}
+	if (existing.ownFields.size < type.ownFields.size) SCHEMA_TYPE_REGISTRY.set(type.name, type);
+};
+
+//#endregion
+//#region src/runtime/parameter.ts
+/**
+* @author ChenTao
+*
+* 1. If object is used by field arguments, don't specify the graphqlTypeName
+* 2. If object is used by directive arguments, graphqlTypeName is required
+*/
+const __marker = Symbol("__parameter_ref_marker");
+var ParameterRef = class ParameterRef {
+	[__marker] = true;
+	constructor(name, graphqlTypeName) {
+		this.name = name;
+		this.graphqlTypeName = graphqlTypeName;
+		if (name.startsWith("$")) throw new Error("parameter name cannot start with '$'");
+	}
+	static of(name, graphqlTypeName) {
+		return new ParameterRef(name, graphqlTypeName);
+	}
+};
+
+//#endregion
+//#region src/runtime/text-builder.ts
+const SCOPE_BRACKETS = {
+	block: ["{", "}"],
+	arguments: ["(", ")"],
+	array: ["[", "]"]
+};
+const DEFAULT_SEPARATORS = {
+	arguments: ", ",
+	array: ", "
+};
+var TextBuilder = class {
+	result = "";
+	atNewLine = false;
+	scopes = [];
+	constructor(indent = "	") {
+		this.indent = indent;
+	}
+	text(value) {
+		const scope = this.scopes.at(-1);
+		if (value && scope && !scope.dirty) {
+			if (scope.multiLines) this.lineBreak();
+			scope.dirty = true;
+		}
+		let remaining = value;
+		while (remaining) {
+			this.flushIndent();
+			const newlineIdx = remaining.indexOf("\n");
+			if (newlineIdx !== -1) {
+				this.result += remaining.substring(0, newlineIdx);
+				this.lineBreak();
+				remaining = remaining.substring(newlineIdx + 1);
+			} else {
+				this.result += remaining;
+				remaining = "";
+			}
+		}
+		return this;
+	}
+	scope(options, action) {
+		const { type, multiLines = false, separator, prefix, suffix } = options;
+		const [open, close] = SCOPE_BRACKETS[type];
+		if (prefix) this.text(prefix);
+		this.text(open);
+		this.scopes.push({
+			type,
+			multiLines,
+			separator: separator ?? DEFAULT_SEPARATORS[type],
+			dirty: false
+		});
+		try {
+			action();
+		} finally {
+			this.scopes.pop();
+			if (multiLines && !this.atNewLine) this.lineBreak();
+			this.text(close);
+			if (suffix) this.text(suffix);
+		}
+		return this;
+	}
+	separator(value) {
+		const scope = this.scopes.at(-1);
+		if (!scope) throw new Error("No existing scope");
+		if (scope.dirty) {
+			const sep = value || scope.separator;
+			if (sep) this.text(sep);
+			if (scope.multiLines) this.lineBreak();
+		}
+		return this;
+	}
+	toString() {
+		return this.result;
+	}
+	flushIndent() {
+		if (this.atNewLine) {
+			this.result += this.indent.repeat(this.scopes.length);
+			this.atNewLine = false;
+		}
+	}
+	lineBreak() {
+		this.result += "\n";
+		this.atNewLine = true;
+	}
+};
+
+//#endregion
+//#region src/runtime/selection.ts
+var SelectionImpl = class SelectionImpl {
+	[__runtime] = this;
+	_fieldMap;
+	_directiveMap;
+	_result;
+	constructor(_ctx, _negative, _field, _args, _child, _fieldOptionsValue, _directive, _directiveArgs, _operationName) {
+		this._ctx = _ctx;
+		this._negative = _negative;
+		this._field = _field;
+		this._args = _args;
+		this._child = _child;
+		this._fieldOptionsValue = _fieldOptionsValue;
+		this._directive = _directive;
+		this._directiveArgs = _directiveArgs;
+		this._operationName = _operationName;
+	}
+	get lastField() {
+		return this._field;
+	}
+	get _schemaType() {
+		return Array.isArray(this._ctx) ? this._ctx[0] : this._ctx._schemaType;
+	}
+	get _enumInputMetadata() {
+		return Array.isArray(this._ctx) ? this._ctx[1] : this._ctx._enumInputMetadata;
+	}
+	get _unionItemTypes() {
+		return Array.isArray(this._ctx) ? this._ctx.length > 2 && this._ctx[2]?.length ? this._ctx[2] : void 0 : this._ctx._unionItemTypes;
+	}
+	get _prev() {
+		return Array.isArray(this._ctx) ? void 0 : this._ctx;
+	}
+	get schemaType() {
+		return this._schemaType;
+	}
+	get operationName() {
+		if (this._operationName !== void 0) return this._operationName;
+		return this._prev?.operationName;
+	}
+	addField(field, args, child, optionsValue) {
+		return new SelectionImpl(this, false, field, args, child, optionsValue);
+	}
+	removeField(field) {
+		if (field === "__typename") throw new Error("__typename cannot be removed");
+		return new SelectionImpl(this, true, field);
+	}
+	addEmbeddable(child, fragmentName) {
+		let fieldName;
+		if (fragmentName !== void 0) {
+			if (fragmentName.length === 0) throw new Error("fragmentName cannot be ''");
+			if (fragmentName.startsWith("on ")) throw new Error("fragmentName cannot start with 'on '");
+			fieldName = `... ${fragmentName}`;
+		} else if (child._schemaType.name === this._schemaType.name || child._unionItemTypes !== void 0) fieldName = "...";
+		else fieldName = `... on ${child._schemaType.name}`;
+		return new SelectionImpl(this, false, fieldName, void 0, child);
+	}
+	addDirective(directive, directiveArgs) {
+		return new SelectionImpl(this, false, "", void 0, void 0, void 0, directive, directiveArgs);
+	}
+	withOperationName(operationName) {
+		if (operationName === void 0) return this;
+		if (operationName.trim().length === 0) throw new Error("operationName cannot be empty");
+		return new SelectionImpl(this, false, "", void 0, void 0, void 0, void 0, void 0, operationName);
+	}
+	get fieldMap() {
+		return this._fieldMap ??= this._buildFieldMap();
+	}
+	get directiveMap() {
+		return this._directiveMap ??= this._buildDirectiveMap();
+	}
+	get variableTypeMap() {
+		return this._serialize().variableTypeMap;
+	}
+	findField(fieldKey) {
+		const field = this.fieldMap.get(fieldKey);
+		if (field) return field;
+		for (const [, f] of this.fieldMap) if (f.name.startsWith("...") && f.childSelections) for (const child of f.childSelections) {
+			const deeper = runtimeOf(child).findField(fieldKey);
+			if (deeper) return deeper;
+		}
+	}
+	findFieldsByName(fieldName) {
+		const out = [];
+		this._collectFieldsByName(fieldName, out);
+		return out;
+	}
+	findFieldByName(fieldName) {
+		const fields = this.findFieldsByName(fieldName);
+		if (fields.length > 1) throw new Error(`Too many fields named "${fieldName}" in selection of type "${this._schemaType.name}"`);
+		return fields[0];
+	}
+	toString() {
+		return this._serialize().text;
+	}
+	toFragmentString() {
+		return this._serialize().fragmentText;
+	}
+	toJSON() {
+		return JSON.stringify(this._serialize());
+	}
+	_buildFieldMap() {
+		const nodes = [];
+		for (let n = this; n; n = n._prev) if (n._field !== "") nodes.push(n);
+		const map = /* @__PURE__ */ new Map();
+		for (let i = nodes.length - 1; i >= 0; --i) {
+			const n = nodes[i];
+			const key = n._fieldOptionsValue?.alias ?? n._field;
+			if (n._field.startsWith("...")) {
+				let children = map.get(key)?.childSelections;
+				if (!children) {
+					children = [];
+					map.set(key, {
+						name: n._field,
+						plural: false,
+						childSelections: children
+					});
+				}
+				children.push(n._child);
+			} else if (n._negative) map.delete(key);
+			else map.set(key, {
+				name: n._field,
+				argGraphQLTypes: n._schemaType.fields.get(n._field)?.argGraphQLTypeMap,
+				args: n._args,
+				fieldOptionsValue: n._fieldOptionsValue,
+				plural: n._schemaType.fields.get(n._field)?.isPlural ?? false,
+				childSelections: n._child ? [n._child] : void 0
+			});
+		}
+		return map;
+	}
+	_buildDirectiveMap() {
+		const map = /* @__PURE__ */ new Map();
+		for (let n = this; n; n = n._prev) if (n._directive !== void 0 && !map.has(n._directive)) map.set(n._directive, n._directiveArgs);
+		return map;
+	}
+	_collectFieldsByName(fieldName, out) {
+		for (const field of this.fieldMap.values()) if (field.name === fieldName) out.push(field);
+		else if (field.name.startsWith("...") && field.childSelections) for (const child of field.childSelections) out.push(...runtimeOf(child).findFieldsByName(fieldName));
+	}
+	_serialize() {
+		return this._result ??= serialize(this);
+	}
+};
+const withOperationName = (selection, operationName) => selection.withOperationName(operationName);
+const serialize = (root) => {
+	const writer = new TextBuilder();
+	const fragmentWriter = new TextBuilder();
+	let ctx = new SerializeContext(writer);
+	ctx.acceptDirectives(root.directiveMap);
+	writer.scope({
+		type: "block",
+		multiLines: true,
+		suffix: "\n"
+	}, () => {
+		ctx.acceptSelection(root);
+	});
+	const renderedFragments = /* @__PURE__ */ new Set();
+	while (true) {
+		const fragmentMap = ctx.namedFragmentMap;
+		if (fragmentMap.size === 0) break;
+		ctx = new SerializeContext(fragmentWriter, ctx);
+		for (const [name, fragment] of fragmentMap) if (renderedFragments.add(name)) {
+			const runtime = runtimeOf(fragment);
+			fragmentWriter.text(`fragment ${name} on ${runtime.schemaType.name} `);
+			ctx.acceptDirectives(runtime.directiveMap);
+			fragmentWriter.scope({
+				type: "block",
+				multiLines: true,
+				suffix: "\n"
+			}, () => {
+				ctx.acceptSelection(fragment);
+			});
+		}
+	}
+	return {
+		text: writer.toString(),
+		fragmentText: fragmentWriter.toString(),
+		variableTypeMap: ctx.variableTypeMap
+	};
+};
+var SerializeContext = class SerializeContext {
+	namedFragmentMap = /* @__PURE__ */ new Map();
+	fragmentNameCounter = /* @__PURE__ */ new Map();
+	fragmentRuntimeNameMap = /* @__PURE__ */ new WeakMap();
+	variableTypeMap;
+	constructor(writer, prev) {
+		this.writer = writer;
+		this.variableTypeMap = prev?.variableTypeMap ?? /* @__PURE__ */ new Map();
+	}
+	acceptSelection(sel) {
+		const t = this.writer.text.bind(this.writer);
+		const runtime = runtimeOf(sel);
+		for (const field of runtime.fieldMap.values()) {
+			const name = field.name;
+			const children = field.childSelections;
+			if (name.startsWith("... ") && !name.startsWith("... on ") && children?.length) {
+				const baseName = name.substring(3).trim();
+				for (const c of children) t(`... ${this.resolveFragmentRuntimeName(baseName, c)}\n`);
+				continue;
+			}
+			if (name !== "...") {
+				const alias = field.fieldOptionsValue?.alias;
+				if (alias && alias !== name) t(`${alias}: `);
+				t(name);
+				if (field.argGraphQLTypes) {
+					const meta = sel._enumInputMetadata;
+					this.acceptArgs(field.args, field.argGraphQLTypes, meta);
+				}
+				this.acceptDirectives(field.fieldOptionsValue?.directives);
+			}
+			if (children?.length) if (name === "...") for (const c of children) this.acceptSelection(c);
+			else {
+				t(" ");
+				this.writer.scope({
+					type: "block",
+					multiLines: true
+				}, () => {
+					for (const c of children) this.acceptSelection(c);
+				});
+			}
+			t("\n");
+		}
+	}
+	resolveFragmentRuntimeName(baseName, selection) {
+		if (this.namedFragmentMap.get(baseName) === selection) return baseName;
+		let byBaseName = this.fragmentRuntimeNameMap.get(selection);
+		if (!byBaseName) {
+			byBaseName = /* @__PURE__ */ new Map();
+			this.fragmentRuntimeNameMap.set(selection, byBaseName);
+		}
+		const existing = byBaseName.get(baseName);
+		if (existing) return existing;
+		let runtimeName = baseName;
+		const occupied = this.namedFragmentMap.get(runtimeName);
+		if (occupied && occupied !== selection) {
+			let idx = this.fragmentNameCounter.get(baseName) ?? 1;
+			while (this.namedFragmentMap.has(`${baseName}_${idx}`)) idx += 1;
+			this.fragmentNameCounter.set(baseName, idx + 1);
+			runtimeName = `${baseName}_${idx}`;
+		}
+		this.namedFragmentMap.set(runtimeName, selection);
+		byBaseName.set(baseName, runtimeName);
+		return runtimeName;
+	}
+	acceptDirectives(directives) {
+		if (!directives) return;
+		for (const [directive, args] of directives) {
+			this.writer.text(`\n@${directive}`);
+			this.acceptArgs(args);
+		}
+	}
+	acceptArgs(args, argGraphQLTypeMap, enumInputMetadata) {
+		if (!args) return;
+		const t = this.writer.text.bind(this.writer);
+		let hasField;
+		if (argGraphQLTypeMap) {
+			hasField = false;
+			for (const argName in args) if (argGraphQLTypeMap.get(argName) !== void 0) {
+				hasField = true;
+				break;
+			} else console.warn(`Unexpected argument: ${argName}`);
+		} else hasField = Object.keys(args).length !== 0;
+		if (hasField) this.writer.scope({
+			type: "arguments",
+			multiLines: isMultilineJSON(args)
+		}, () => {
+			for (const argName in args) {
+				this.writer.separator();
+				const arg = args[argName];
+				if (argGraphQLTypeMap) {
+					const typeName = argGraphQLTypeMap.get(argName);
+					if (typeName !== void 0) if (arg?.[__marker]) {
+						const ref = arg;
+						this.registerVariableType(ref, typeName, false, "field argument");
+						t(`${argName}: $${ref.name}`);
+					} else {
+						t(`${argName}: `);
+						this.acceptLiteral(arg, SerializeContext.enumMetaType(enumInputMetadata, typeName), typeName);
+					}
+					else throw new Error(`Unknown argument '${argName}'`);
+				} else if (arg?.[__marker]) {
+					const ref = arg;
+					if (!ref.graphqlTypeName) throw new Error(`Directive argument '${ref.name}' requires graphqlTypeName`);
+					this.registerVariableType(ref, ref.graphqlTypeName, false, "directive argument");
+					t(`${argName}: $${ref.name}`);
+				} else {
+					t(`${argName}: `);
+					this.acceptLiteral(arg, void 0, void 0);
+				}
+			}
+		});
+	}
+	acceptLiteral(value, metaType, graphqlTypeName) {
+		const t = this.writer.text.bind(this.writer);
+		if (value == null) {
+			t("null");
+			return;
+		}
+		if (typeof value === "number") {
+			t(value.toString());
+			return;
+		}
+		if (typeof value === "string") {
+			t(metaType ? value : JSON.stringify(value));
+			return;
+		}
+		if (typeof value === "boolean") {
+			t(value ? "true" : "false");
+			return;
+		}
+		if (value?.[__marker]) {
+			const ref = value;
+			if (!graphqlTypeName && !ref.graphqlTypeName) throw new Error(`Argument '${ref.name}' nested type cannot be inferred; provide graphqlTypeName`);
+			this.registerVariableType(ref, graphqlTypeName, true, "nested argument");
+			t(`$${ref.name}`);
+			return;
+		}
+		if (value instanceof StringValue) {
+			t(value.quotationMarks ? JSON.stringify(value.value) : value.value);
+			return;
+		}
+		if (Array.isArray(value) || value instanceof Set) {
+			const elementGraphQLTypeName = SerializeContext.elementTypeName(graphqlTypeName);
+			this.writer.scope({ type: "array" }, () => {
+				for (const e of value) {
+					this.writer.separator(", ");
+					this.acceptLiteral(e, metaType, elementGraphQLTypeName);
+				}
+			});
+		} else if (value instanceof Map) this.writer.scope({ type: "block" }, () => {
+			for (const [k, v] of value) {
+				this.writer.separator(", ");
+				this.writer.text(k);
+				t(": ");
+				this.acceptLiteral(v, metaType?.fields?.get(k), metaType?.fieldGraphQLTypeMap?.get(k));
+			}
+		});
+		else if (typeof value === "object") this.writer.scope({ type: "block" }, () => {
+			for (const k in value) {
+				this.writer.separator(", ");
+				this.writer.text(k);
+				t(": ");
+				this.acceptLiteral(value[k], metaType?.fields?.get(k), metaType?.fieldGraphQLTypeMap?.get(k));
+			}
+		});
+	}
+	registerVariableType(ref, expectedTypeName, allowImplicitFromRef = false, context = "argument") {
+		const typeName = expectedTypeName ?? (allowImplicitFromRef ? ref.graphqlTypeName : void 0);
+		if (!typeName) throw new Error(`Directive argument '${ref.name}' requires graphqlTypeName`);
+		if (ref.graphqlTypeName && ref.graphqlTypeName !== typeName) throw new Error(`Argument '${ref.name}' type conflict: '${typeName}' vs ParameterRef '${ref.graphqlTypeName}' (${context})`);
+		const existing = this.variableTypeMap.get(ref.name);
+		if (existing && existing !== typeName) throw new Error(`Argument '${ref.name}' type conflict: '${existing}' vs '${typeName}' (${context})`);
+		this.variableTypeMap.set(ref.name, typeName);
+	}
+	static enumMetaType(meta, typeName) {
+		if (!meta || !typeName) return void 0;
+		return meta.get(typeName.split(/\[|\]|!/).join(""));
+	}
+	static elementTypeName(typeName) {
+		if (!typeName) return void 0;
+		let normalized = typeName.trim();
+		if (normalized.endsWith("!")) normalized = normalized.slice(0, -1).trim();
+		if (normalized.startsWith("[") && normalized.endsWith("]")) return normalized.slice(1, -1).trim();
+		return normalized;
+	}
+};
+const isMultilineJSON = (obj) => {
+	let size = 0;
+	if (Array.isArray(obj)) for (const v of obj) {
+		if (typeof v === "object" && !v?.[__marker]) return true;
+		if (++size > 2) return true;
+	}
+	else if (typeof obj === "object" && obj !== null) for (const k of Reflect.ownKeys(obj)) {
+		const v = obj[k];
+		if (typeof v === "object" && !v?.[__marker]) return true;
+		if (++size > 2) return true;
+	}
+	return false;
+};
+
+//#endregion
+//#region src/runtime/field-options.ts
+var FieldOptions = class FieldOptions {
+	_value;
+	constructor(_prev, _alias, _directive, _directiveArgs) {
+		this._prev = _prev;
+		this._alias = _alias;
+		this._directive = _directive;
+		this._directiveArgs = _directiveArgs;
+	}
+	alias(alias) {
+		return new FieldOptions(this, alias);
+	}
+	directive(directive, args) {
+		if (directive.startsWith("@")) throw new Error("directive name should not start with '@', it will be prepended automatically");
+		return new FieldOptions(this, void 0, directive, args);
+	}
+	get value() {
+		return this._value ??= this._buildValue();
+	}
+	_buildValue() {
+		let alias;
+		const directives = /* @__PURE__ */ new Map();
+		for (let node = this; node; node = node._prev) {
+			if (node._alias !== void 0 && alias === void 0) alias = node._alias;
+			if (node._directive !== void 0 && !directives.has(node._directive)) {
+				const args = node._directiveArgs;
+				directives.set(node._directive, args && Object.keys(args).length !== 0 ? args : void 0);
+			}
+		}
+		return {
+			alias,
+			directives
+		};
+	}
+};
+const createFieldOptions = () => {
+	return new FieldOptions();
+};
+
+//#endregion
+//#region src/runtime/enum-metadata.ts
+/**
+* 元数据构建器
+*
+* codegen 生成的代码会调用此构建器来注册 schema 中的 enum/input 类型：
+* ```ts
+* const builder = new EnumInputMetadataBuilder();
+* builder.add("Status");                           // enum
+* builder.add("CreateInput", [{name: "status", typeName: "Status"}]); // input
+* export const ENUM_INPUT_METADATA = builder.build();
+* ```
+*/
+var EnumInputMetadataBuilder = class EnumInputMetadataBuilder {
+	typeMap = /* @__PURE__ */ new Map();
+	static BUILTIN_SCALARS = new Set([
+		"ID",
+		"String",
+		"Int",
+		"Float",
+		"Boolean"
+	]);
+	/** 注册一个枚举/输入类型。无 fields 参数表示 ENUM，有则表示 INPUT */
+	add(name, fields) {
+		this.typeMap.set(name, fields);
+		return this;
+	}
+	/** 构建不可变的元数据表 */
+	build() {
+		const result = /* @__PURE__ */ new Map();
+		const resolve = (name) => {
+			const existing = result.get(name);
+			if (existing) return existing;
+			if (!this.typeMap.has(name)) throw new Error(`Unknown enum/input type: '${name}'`);
+			const rawFields = this.typeMap.get(name);
+			let fields;
+			let fieldGraphQLTypeMap;
+			if (rawFields) {
+				fields = /* @__PURE__ */ new Map();
+				fieldGraphQLTypeMap = /* @__PURE__ */ new Map();
+				for (const { name: fieldName, typeName, graphqlTypeName, isLeaf } of rawFields) {
+					let resolved;
+					if (!(isLeaf || EnumInputMetadataBuilder.BUILTIN_SCALARS.has(typeName))) {
+						if (!this.typeMap.has(typeName)) throw new Error(`Unknown enum/input type: '${typeName}'`);
+						resolved = resolve(typeName);
+					}
+					fields.set(fieldName, resolved);
+					if (graphqlTypeName) fieldGraphQLTypeMap.set(fieldName, graphqlTypeName);
+				}
+			}
+			const metaType = {
+				type: rawFields === void 0 ? "ENUM" : "INPUT",
+				name,
+				fields,
+				fieldGraphQLTypeMap
+			};
+			result.set(name, metaType);
+			return metaType;
+		};
+		for (const name of this.typeMap.keys()) resolve(name);
+		return result;
+	}
+};
+
+//#endregion
+//#region src/runtime/proxy.ts
+const createSelection = (schemaType, enumInputMetadata, unionEntityTypes) => {
+	return new Proxy(new SelectionImpl([
+		schemaType,
+		enumInputMetadata,
+		unionEntityTypes
+	], false, ""), proxyHandler(schemaType));
+};
+const BUILT_DIRECTIVES = new Set([
+	"$omit",
+	"$alias",
+	"$directive",
+	"$include",
+	"$skip",
+	"$on",
+	"$use"
+]);
+const resolveValueOrThunk = (value) => {
+	return typeof value === "function" ? value() : value;
+};
+const createChildSelectionProxy = (schemaType, enumInputMetadata) => {
+	return new Proxy(new SelectionImpl([
+		schemaType,
+		enumInputMetadata,
+		void 0
+	], false, ""), proxyHandler(schemaType));
+};
+const buildRequiredArgs = (argTypeMap) => {
+	if (!argTypeMap.size) return void 0;
+	const requiredArgNames = Array.from(argTypeMap.entries()).filter(([, type]) => type.endsWith("!")).map(([name]) => name);
+	if (!requiredArgNames.length) return void 0;
+	const args = {};
+	for (const name of requiredArgNames) args[name] = ParameterRef.of(name);
+	return args;
+};
+const resolveAssociationTarget = (fieldName, fieldTargetTypeName, ownerTypeName) => {
+	if (!fieldTargetTypeName) throw new Error(`Field "${fieldName}" has no target type`);
+	const targetSchemaType = resolveRegisteredSchemaType(fieldTargetTypeName);
+	if (!targetSchemaType) throw new Error(`Cannot resolve schema type "${fieldTargetTypeName}" for field "${fieldName}" on "${ownerTypeName}"`);
+	return targetSchemaType;
+};
+const parseAssociationArgs = (argArray) => {
+	let args;
+	let childSelectionFactory;
+	let childSelection;
+	for (const arg of argArray) if (arg instanceof SelectionImpl) childSelection = arg;
+	else if (typeof arg === "function") childSelectionFactory = arg;
+	else args = arg;
+	return {
+		args,
+		childSelectionFactory,
+		childSelection
+	};
+};
+const parseMethodArgs = (argArray) => {
+	let args;
+	let child;
+	let optionsValue;
+	for (const arg of argArray) if (arg instanceof SelectionImpl) child = arg;
+	else if (typeof arg === "function") optionsValue = arg(createFieldOptions()).value;
+	else args = arg;
+	return {
+		args,
+		child,
+		optionsValue
+	};
+};
+const findLastFieldSelection = (selection, lastField) => {
+	const byKey = selection.fieldMap.get(lastField);
+	if (byKey) return byKey;
+	const byName = selection.findFieldsByName(lastField);
+	return byName.length ? byName[0] : void 0;
+};
+const rewriteLastFieldWithOptions = (selection, lastField, optionsValue) => {
+	const existing = findLastFieldSelection(selection, lastField);
+	let current = selection.removeField(lastField);
+	current = current.addField(lastField, existing?.args, existing?.childSelections?.[0], optionsValue);
+	return current;
+};
+const mergeLastFieldDirective = (selection, lastField, directiveName, directiveArgs) => {
+	const existing = findLastFieldSelection(selection, lastField);
+	const directives = new Map(existing?.fieldOptionsValue?.directives ?? []);
+	directives.set(directiveName, directiveArgs);
+	return rewriteLastFieldWithOptions(selection, lastField, {
+		alias: existing?.fieldOptionsValue?.alias,
+		directives
+	});
+};
+const proxyHandler = (schemaType) => {
+	const handler = { get: (target, p, _receiver) => {
+		if (p === "schemaType") return schemaType;
+		if (typeof p === "string") {
+			if (BUILT_DIRECTIVES.has(p)) return new Proxy(DUMMY, methodHandler(target, handler, p));
+			else if (schemaType.fields.has(p)) {
+				const field = schemaType.fields.get(p);
+				if (field.isAssociation || field.targetTypeName !== void 0) return (...argArray) => {
+					const targetSchemaType = resolveAssociationTarget(p, field.targetTypeName, schemaType.name);
+					let { args, childSelectionFactory, childSelection } = parseAssociationArgs(argArray);
+					if (childSelectionFactory) childSelection = childSelectionFactory(createChildSelectionProxy(targetSchemaType, target._enumInputMetadata));
+					if (!childSelection) throw new Error(`Field "${p}" requires a child selection`);
+					if (!args) args = buildRequiredArgs(field.argGraphQLTypeMap);
+					return new Proxy(target.addField(p, args, childSelection), handler);
+				};
+				if (field.isFunction) return new Proxy(DUMMY, methodHandler(target, handler, p));
+				return new Proxy(target.addField(p), handler);
+			}
+		}
+		return Reflect.get(target, p, target);
+	} };
+	return handler;
+};
+const methodHandler = (targetSelection, handler, field) => {
+	return { apply: (_1, _2, argArray) => {
+		if (field === "$on") {
+			let childSelection;
+			if (typeof argArray[0] === "string" && typeof argArray[1] === "function") {
+				const targetTypeName = argArray[0];
+				const builder = argArray[1];
+				const targetSchemaType = resolveRegisteredSchemaType(targetTypeName);
+				if (!targetSchemaType) throw new Error(`Cannot resolve schema type "${targetTypeName}" for $on`);
+				childSelection = builder(createChildSelectionProxy(targetSchemaType, targetSelection._enumInputMetadata));
+			} else if (typeof argArray[0] === "function") {
+				const builder = argArray[0];
+				const targetSchemaType = targetSelection.schemaType;
+				childSelection = builder(createChildSelectionProxy(targetSchemaType, targetSelection._enumInputMetadata));
+			} else throw new Error("$on requires a builder or (typeName, builder) arguments");
+			let parent = targetSelection;
+			if (targetSelection.schemaType.name !== runtimeOf(childSelection).schemaType.name) parent = targetSelection.addField("__typename");
+			return new Proxy(parent.addEmbeddable(childSelection, void 0), handler);
+		}
+		if (field === "$use") {
+			const fragment = resolveValueOrThunk(argArray[0]);
+			if (!fragment || !fragment[__fragment_spread]) throw new Error("$use requires a fragment created by fragment$");
+			const childSelection = fragment.selection;
+			let parent = targetSelection;
+			if (targetSelection.schemaType.name !== runtimeOf(childSelection).schemaType.name) parent = targetSelection.addField("__typename");
+			return new Proxy(parent.addEmbeddable(childSelection, fragment.name), handler);
+		}
+		if (field === "$omit") {
+			let current = targetSelection;
+			for (const fieldName of argArray) if (typeof fieldName === "string") current = current.removeField(fieldName);
+			return new Proxy(current, handler);
+		}
+		if (field === "$alias") {
+			const alias = argArray[0];
+			const lastField = targetSelection.lastField;
+			if (!lastField) throw new Error("$alias requires a preceding field selection");
+			const existing = findLastFieldSelection(targetSelection, lastField);
+			const current = rewriteLastFieldWithOptions(targetSelection, lastField, {
+				alias,
+				directives: new Map(existing?.fieldOptionsValue?.directives ?? [])
+			});
+			return new Proxy(current, handler);
+		}
+		if (field === "$directive") {
+			const lastField = targetSelection.lastField;
+			if (!lastField) return new Proxy(targetSelection.addDirective(argArray[0], argArray[1]), handler);
+			const current = mergeLastFieldDirective(targetSelection, lastField, argArray[0], argArray[1]);
+			return new Proxy(current, handler);
+		}
+		if (field === "$include" || field === "$skip") {
+			const directiveName = field === "$include" ? "include" : "skip";
+			const directiveArgs = { if: argArray[0] };
+			const lastField = targetSelection.lastField;
+			if (!lastField) return new Proxy(targetSelection.addDirective(directiveName, directiveArgs), handler);
+			const current = mergeLastFieldDirective(targetSelection, lastField, directiveName, directiveArgs);
+			return new Proxy(current, handler);
+		}
+		let { args, child, optionsValue } = parseMethodArgs(argArray);
+		if (!args) {
+			const argMap = targetSelection.schemaType.ownFields.get(field)?.argGraphQLTypeMap;
+			args = argMap ? buildRequiredArgs(argMap) : void 0;
+		}
+		return new Proxy(targetSelection.addField(field, args, child, optionsValue), handler);
+	} };
+};
+const DUMMY = () => {};
+const SELECTION_TARGET = new SelectionImpl([
+	createSchemaType("Any", "OBJECT", [], []),
+	new EnumInputMetadataBuilder().build(),
+	void 0
+], false, "");
+
+//#endregion
+//#region src/runtime/cyrb53.ts
+const cyrb53 = (str, seed = 0) => {
+	let h1 = 3735928559 ^ seed;
+	let h2 = 1103547991 ^ seed;
+	for (let i = 0; i < str.length; i++) {
+		const ch = str.charCodeAt(i);
+		h1 = Math.imul(h1 ^ ch, 2654435761);
+		h2 = Math.imul(h2 ^ ch, 1597334677);
+	}
+	h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507);
+	h1 ^= Math.imul(h2 ^ h2 >>> 13, 3266489909);
+	h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507);
+	h2 ^= Math.imul(h1 ^ h1 >>> 13, 3266489909);
+	return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(36);
+};
+
+//#endregion
+exports.EnumInputMetadataBuilder = EnumInputMetadataBuilder;
+exports.FragmentRef = FragmentRef;
+exports.FragmentSpread = FragmentSpread;
+exports.ParameterRef = ParameterRef;
+exports.SelectionNode = SelectionImpl;
+exports.StringValue = StringValue;
+exports.TextBuilder = TextBuilder;
+exports.__parameterRefMarker = __marker;
+exports.createSchemaType = createSchemaType;
+exports.createSelection = createSelection;
+exports.cyrb53 = cyrb53;
+exports.registerSchemaTypeFactory = registerSchemaTypeFactory;
+exports.resolveRegisteredSchemaType = resolveRegisteredSchemaType;
+exports.runtimeOf = runtimeOf;
+exports.withOperationName = withOperationName;