@ptdgrp/typedgql 1.0.0-beta.15 → 1.0.0-beta.20

package/dist/index.mjs

@@ -1,921 +1,4 @@
-//#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);
-	}
-};
+import { a as withOperationName, c as __marker, d as resolveRegisteredSchemaType, f as FragmentRef, h as runtimeOf, i as SelectionImpl, l as createSchemaType, m as StringValue, n as createSelection, o as TextBuilder, p as FragmentSpread, r as EnumInputMetadataBuilder, s as ParameterRef, t as cyrb53, u as registerSchemaTypeFactory } from "./cyrb53-B2tdX6NT.mjs";
+import "./runtime.mjs";
 
-//#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
-/**
-* Runtime marker for `ParameterRef`.
-*
-* We use a unique symbol instead of string keys to avoid accidental collision
-* with user objects passed as argument literals.
-*/
-const __marker = Symbol("__parameter_ref_marker");
-var ParameterRef = class ParameterRef {
-	[__marker] = true;
-	constructor(name, explicitType) {
-		this.name = name;
-		this.explicitType = explicitType;
-		if (name.startsWith("$")) throw new Error("parameter name cannot start with '$'");
-	}
-	/**
-	* Represents a GraphQL variable reference used in DSL argument objects.
-	*
-	* Example:
-	* - `id: ParameterRef.of("postId")` -> `id: $postId`
-	*
-	* Main use cases:
-	* 1. Rename/bind a field argument to a different variable name.
-	* 2. Explicitly annotate variable type when runtime cannot infer it from a
-	*    field argument position (for example directive args or nested literals).
-	*
-	* When `explicitType` is NOT needed:
-	* - Field arg slot with schema type:
-	*   `q.user({ id: ParameterRef.of("userId") }, (u) => u.id)`
-	*   `id` type is inferred from schema (`ID!`).
-	*
-	* When `explicitType` IS needed:
-	* - Directive arg slot:
-	*   `node.$directive("include", { if: ParameterRef.of("withEmail", "Boolean!") })`
-	* - Nested input slot without direct arg type context:
-	*   `q.search({ filter: { keyword: ParameterRef.of("kw", "String!") } }, ...)`
-	*/
-	static of(name, explicitType) {
-		return new ParameterRef(name, explicitType);
-	}
-};
-
-//#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, `field '${runtime.schemaType.name}.${name}'`);
-				}
-				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, void 0, void 0, `directive '@${directive}'`);
-		}
-	}
-	acceptArgs(args, argGraphQLTypeMap, enumInputMetadata, argContext = "argument") {
-		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, `${argContext}.${argName}`);
-						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.explicitType) throw new Error(`Cannot infer the type of directive argument '${ref.name}'; an explicit type annotation is required.`);
-					this.registerVariableType(ref, ref.explicitType, false, `${argContext}.${argName}`);
-					t(`${argName}: $${ref.name}`);
-				} else {
-					t(`${argName}: `);
-					this.acceptLiteral(arg, void 0, void 0);
-				}
-			}
-		});
-	}
-	acceptLiteral(value, metaType, explicitType) {
-		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 (!explicitType && !ref.explicitType) throw new Error(`Cannot infer the nested type of argument '${ref.name}'; an explicit type annotation is required.`);
-			this.registerVariableType(ref, explicitType, 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(explicitType);
-			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.explicitType : void 0);
-		if (!typeName) throw new Error(`Cannot infer the type of directive argument '${ref.name}'; an explicit type annotation is required.`);
-		if (ref.explicitType && ref.explicitType !== typeName) throw new Error(`Variable '$${ref.name}' has conflicting GraphQL types at ${context}: inferred '${typeName}', but ParameterRef declares '${ref.explicitType}'`);
-		const existing = this.variableTypeMap.get(ref.name);
-		if (existing && existing.typeName !== typeName) throw new Error(`Variable '$${ref.name}' has conflicting GraphQL types: first '${existing.typeName}' at ${existing.source}, then '${typeName}' at ${context}`);
-		this.variableTypeMap.set(ref.name, {
-			typeName,
-			source: context
-		});
-	}
-	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 resolveAutoPropagatedArgs = (declaredArgTypeMap, providedArgs) => {
-	if (!declaredArgTypeMap?.size) return providedArgs;
-	const autoArgs = {};
-	for (const argName of declaredArgTypeMap.keys()) autoArgs[argName] = ParameterRef.of(argName);
-	if (!providedArgs) return autoArgs;
-	return {
-		...autoArgs,
-		...providedArgs
-	};
-};
-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`);
-					const resolvedArgs = resolveAutoPropagatedArgs(field.argGraphQLTypeMap, args);
-					return new Proxy(target.addField(p, resolvedArgs, 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);
-		const declaredArgTypeMap = targetSelection.schemaType.fields.get(field)?.argGraphQLTypeMap;
-		const resolvedArgs = resolveAutoPropagatedArgs(declaredArgTypeMap, args);
-		return new Proxy(targetSelection.addField(field, resolvedArgs, 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
-export { EnumInputMetadataBuilder, FragmentRef, FragmentSpread, ParameterRef, SelectionImpl as SelectionNode, StringValue, TextBuilder, __marker as __parameterRefMarker, createSchemaType, createSelection, cyrb53, registerSchemaTypeFactory, resolveRegisteredSchemaType, runtimeOf, withOperationName };
-//# sourceMappingURL=index.mjs.map
+export { EnumInputMetadataBuilder, FragmentRef, FragmentSpread, ParameterRef, SelectionImpl as SelectionNode, StringValue, TextBuilder, __marker as __parameterRefMarker, createSchemaType, createSelection, cyrb53, registerSchemaTypeFactory, resolveRegisteredSchemaType, runtimeOf, withOperationName };