@qds.dev/tools 0.11.2 → 0.13.0

package/lib/linter/qds-internal.d.ts

@@ -3,5 +3,208 @@
  *
  * Custom linting rules specific to Qwik patterns and conventions
  */
-declare const qdsPlugin: import("oxlint").Plugin;
+interface Ranged {
+    range: [number, number];
+}
+interface Node extends Ranged {
+    type: string;
+    start: number;
+    end: number;
+}
+interface Context {
+    filename: string;
+    report(descriptor: {
+        node: Ranged;
+        messageId?: string;
+        message?: string;
+        data?: Record<string, string>;
+    }): void;
+}
+export declare const requireContextProxyRule: {
+    readonly meta: {
+        readonly type: "problem";
+        readonly docs: {
+            readonly description: "Enforce createContextProxy pattern for getter exports";
+            readonly recommended: true;
+        };
+        readonly messages: {
+            readonly nonStringArg: "Getter export '{{name}}' calls context() with a non-string argument. Use a string literal: context('fieldName').";
+            readonly notContextProxy: "Getter export '{{name}}' is not created via createContextProxy. Use: const context = createContextProxy<T>(); export const {{name}} = context('fieldName');";
+            readonly missingArg: "Getter export '{{name}}' calls context() without arguments. Provide the context field name: context('fieldName').";
+            readonly missingGetPrefix: "Export '{{name}}' uses createContextProxy but is missing the 'get' prefix. Rename to 'get{{suggested}}' so the UI plugin can detect it.";
+            readonly getterNameMismatch: "Getter '{{name}}' does not match context field '{{field}}'. Expected export name: 'get{{expected}}' (derived: '{{derived}}', actual field: '{{field}}'). The UI plugin uses deriveContextField which strips 'get' and lowercases the next char.";
+        };
+        readonly schema: readonly [];
+    };
+    readonly create: (context: Context) => {
+        ImportDeclaration(node: Node): void;
+        VariableDeclarator(node: Node): void;
+        ExportNamedDeclaration(node: Node): void;
+    };
+};
+declare const qdsPlugin: {
+    readonly meta: {
+        readonly name: "qds-internal";
+    };
+    readonly rules: {
+        readonly "no-default-name": {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Disallow 'defaultX' naming pattern in component props - use Qwik's signal/value-based patterns instead";
+                    readonly category: "Best Practices";
+                    readonly recommended: true;
+                    readonly url: "https://qds.dev/contributing/state/";
+                };
+                readonly messages: {
+                    readonly defaultXPattern: "'{{name}}' uses React's defaultX pattern. Qwik uses signal-based (two-way binding) or value-based (one-way binding) patterns instead. See: https://qds.dev/contributing/state/";
+                };
+                readonly schema: readonly [];
+            };
+            readonly createOnce: (context: Context) => {
+                TSPropertySignature(node: Node): void;
+            };
+        };
+        readonly "event-handlers-array-pattern": {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Event handlers should use array pattern to combine local handlers with props";
+                    readonly category: "Best Practices";
+                    readonly recommended: true;
+                    readonly url: "https://qds.dev/contributing/";
+                };
+                readonly messages: {
+                    readonly requireArrayPattern: "Event handler '{{name}}' should use array pattern: [localHandler$, props.{{name}}].";
+                };
+                readonly schema: readonly [];
+            };
+            readonly createOnce: (context: Context) => {
+                JSXAttribute(node: Node): void;
+            };
+        };
+        readonly "one-element-composition": {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Components should follow 'One Component, One Markup Element' principle";
+                    readonly category: "Best Practices";
+                    readonly recommended: true;
+                    readonly url: "https://qds.dev/contributing/composition/";
+                };
+                readonly messages: {
+                    readonly multipleElements: "Component returns multiple HTML element types: {{elements}}. Each component should correspond to ONE type of markup element. Add '// no-composition-check' to exempt.";
+                };
+                readonly schema: readonly [];
+            };
+            readonly createOnce: (context: Context) => {
+                Program(): void;
+                VariableDeclarator(node: Node): void;
+                ReturnStatement(node: Node): void;
+                "VariableDeclarator:exit"(node: Node): void;
+            };
+        };
+        readonly "require-use-bindings": {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Root components (*-root.tsx) should use useBindings or include '// no-bindings' comment";
+                    readonly category: "Best Practices";
+                    readonly recommended: true;
+                    readonly url: "https://qds.dev/contributing/state/#useBindings";
+                };
+                readonly messages: {
+                    readonly missingBindings: "Root component is missing useBindings. Add useBindings or include '// no-bindings' comment if not needed.";
+                };
+                readonly schema: readonly [];
+            };
+            readonly createOnce: (context: Context) => {
+                Program(): void;
+                CallExpression(node: Node): void;
+                "Program:exit"(): void;
+            };
+        };
+        readonly "require-destructure-bindings": {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "If useBindings is used, destructureBindings must also be used in the same file to ensure proper prop handling";
+                    readonly category: "Best Practices";
+                    readonly recommended: true;
+                    readonly url: "https://qds.dev/contributing/state/#destructureBindings";
+                };
+                readonly messages: {
+                    readonly missingDestructureBindings: "File uses useBindings but is missing destructureBindings. Both are required for proper QDS component state management. Example: const { ... } = destructureBindings(props, initialValues);";
+                };
+                readonly schema: readonly [];
+            };
+            readonly createOnce: (context: Context) => {
+                CallExpression(node: Node): void;
+                "Program:exit"(): void;
+            };
+        };
+        readonly "require-research-file": {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Root components (*-root.tsx) require a research file (research.md or research.mdx)";
+                    readonly category: "Best Practices";
+                    readonly recommended: true;
+                    readonly url: "https://qwik.design/contributing/research/";
+                };
+                readonly messages: {
+                    readonly missingResearch: "Root component requires a research file. Create research.md or research.mdx in this directory documenting component research, accessibility, design decisions, and usage guidelines.";
+                };
+                readonly schema: readonly [];
+            };
+            readonly createOnce: (context: Context) => {
+                Program(): void;
+                CallExpression(node: Node): void;
+                "Program:exit"(): void;
+            };
+        };
+        readonly "require-test-file": {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Root components (*-root.tsx) require a test file (*.browser.tsx)";
+                    readonly category: "Best Practices";
+                    readonly recommended: true;
+                    readonly url: "https://qwik.design/contributing/testing/";
+                };
+                readonly messages: {
+                    readonly missingTest: "Root component requires a test file. Create a *.browser.tsx file in this directory with component tests.";
+                };
+                readonly schema: readonly [];
+            };
+            readonly createOnce: (context: Context) => {
+                Program(): void;
+                CallExpression(node: Node): void;
+                "Program:exit"(): void;
+            };
+        };
+        readonly "require-context-proxy": {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Enforce createContextProxy pattern for getter exports";
+                    readonly recommended: true;
+                };
+                readonly messages: {
+                    readonly nonStringArg: "Getter export '{{name}}' calls context() with a non-string argument. Use a string literal: context('fieldName').";
+                    readonly notContextProxy: "Getter export '{{name}}' is not created via createContextProxy. Use: const context = createContextProxy<T>(); export const {{name}} = context('fieldName');";
+                    readonly missingArg: "Getter export '{{name}}' calls context() without arguments. Provide the context field name: context('fieldName').";
+                    readonly missingGetPrefix: "Export '{{name}}' uses createContextProxy but is missing the 'get' prefix. Rename to 'get{{suggested}}' so the UI plugin can detect it.";
+                    readonly getterNameMismatch: "Getter '{{name}}' does not match context field '{{field}}'. Expected export name: 'get{{expected}}' (derived: '{{derived}}', actual field: '{{field}}'). The UI plugin uses deriveContextField which strips 'get' and lowercases the next char.";
+                };
+                readonly schema: readonly [];
+            };
+            readonly create: (context: Context) => {
+                ImportDeclaration(node: Node): void;
+                VariableDeclarator(node: Node): void;
+                ExportNamedDeclaration(node: Node): void;
+            };
+        };
+    };
+};
 export default qdsPlugin;

package/lib/linter/qds.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Oxlint plugin for Qwik Design System (public)
+ *
+ * Consumer-facing lint plugin that QDS users install in their own projects.
+ * Contains only the no-outside-getter-usage rule.
+ */
+interface Ranged {
+    range: [number, number];
+}
+interface Node extends Ranged {
+    type: string;
+    start: number;
+    end: number;
+}
+interface Context {
+    filename: string;
+    report(descriptor: {
+        node: Ranged;
+        messageId?: string;
+        message?: string;
+        data?: Record<string, string>;
+    }): void;
+}
+declare const qdsPlugin: {
+    readonly meta: {
+        readonly name: "qds";
+    };
+    readonly rules: {
+        readonly "no-outside-getter-usage": {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Getters from QDS namespaces must be used inside a component$ that renders the matching root element";
+                    readonly category: "Best Practices";
+                    readonly recommended: true;
+                    readonly url: "https://qds.dev/contributing/state/";
+                };
+                readonly messages: {
+                    readonly moduleScope: "'{{getter}}' used at module scope. Getters must be used inside a component$ that renders <{{namespace}}.root> or any of its descendants.";
+                    readonly outsideComponent: "'{{getter}}' used in a function outside any component$. Move this into a component$ rendered inside <{{namespace}}.root>.";
+                    readonly noMatchingRoot: "'{{getter}}' used but no <{{namespace}}.root> found in JSX return. Add <{{namespace}}.root> or move this into a component that renders inside one.";
+                };
+                readonly schema: readonly [];
+            };
+            readonly create: (context: Context) => {
+                ImportDeclaration(node: Node): void;
+                CallExpression(node: Node): void;
+                "CallExpression:exit"(node: Node): void;
+                "Program:exit"(): void;
+                FunctionDeclaration(node: Node): void;
+                "FunctionDeclaration:exit"(node: Node): void;
+                JSXMemberExpression(node: Node): void;
+                MemberExpression(node: Node): void;
+                VariableDeclarator(node: Node): void;
+            };
+        };
+    };
+};
+export default qdsPlugin;

package/lib/linter/qds.unit.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/linter/rule-tester.d.ts

@@ -1,4 +1,26 @@
-import type { Ranged, Rule } from "oxlint";
+interface Ranged {
+    range: [number, number];
+}
+interface Context {
+    filename: string;
+    report(descriptor: {
+        node: Ranged;
+        messageId?: string;
+        message?: string;
+        data?: Record<string, string>;
+    }): void;
+}
+type VisitorWithHooks = Record<string, unknown> & {
+    before?: () => boolean | void;
+    after?: () => void;
+};
+type Rule = {
+    meta: Record<string, unknown>;
+    createOnce: (context: Context) => VisitorWithHooks;
+} | {
+    meta: Record<string, unknown>;
+    create: (context: Context) => VisitorWithHooks;
+};
 export interface ValidTestCase {
     /** The code that should not trigger any errors */
     code: string;

package/lib/playground/prop-extraction.d.ts

@@ -1,4 +1,4 @@
-import type { Node } from "@oxc-project/types";
+import type { Node, TSPropertySignature } from "@oxc-project/types";
 import type { Plugin as VitePlugin } from "vite";
 export type PropType = {
     name: string;
@@ -26,7 +26,12 @@ export type ComponentPropsPluginOptions = {
 export declare const propExtraction: (options: ComponentPropsPluginOptions) => VitePlugin;
 export declare function generateAllComponentMetadata(componentsDir: string, outputDir: string, debug: (message: string, ...data: unknown[]) => void): Promise<void>;
 export declare function generateComponentMetadata(componentName: string, componentsDir: string, outputDir: string, debug: (message: string, ...data: unknown[]) => void): Promise<void>;
+export declare function isPieceFile(file: string, debug: (message: string, ...data: unknown[]) => void): boolean;
+export declare function extractPieceName(file: string, componentName: string): string;
+export declare function getInterfaceName(node: Node): string;
+export declare function getTypeMembers(node: unknown): TSPropertySignature[];
 export declare function extractJSDoc(node: Node, source: string, propName?: string): {
     comment?: string;
     scenario?: string;
 };
+export declare function extractComponentName(filePath: string, componentsDir: string): string | null;

package/lib/playground/prop-extraction.qwik.mjs

@@ -1,8 +1,8 @@
+import { existsSync, statSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
 import { charIn, charNotIn, createRegExp, exactly, maybe, oneOrMore, whitespace } from "magic-regexp";
 import { parseSync } from "oxc-parser";
 import { walk } from "oxc-walker";
-import { existsSync, statSync } from "node:fs";
-import { dirname, join, relative } from "node:path";
 import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 
 //#region playground/prop-extraction.ts
@@ -163,6 +163,10 @@ function buildTypeAliasCache(program) {
 			const typeName = getTypeName(node);
 			if (typeName) cache.set(typeName, node);
 		}
+		if (node.type === "TSInterfaceDeclaration") {
+			const typeName = getInterfaceName(node);
+			if (typeName) cache.set(typeName, node);
+		}
 	} });
 	return cache;
 }
@@ -239,7 +243,43 @@ function analyzeProgram(program, debug, typeAliasCache) {
 				}
 			}
 		}
+		if (node.type === "TSInterfaceDeclaration") {
+			const typeName = getInterfaceName(node);
+			if (!typeName) return;
+			if (!propsType && typeName.endsWith("Props")) {
+				debug(`Found *Props interface: ${typeName}`);
+				propsType = node;
+			}
+			if (typeName.endsWith("Props")) {
+				const extendsClause = "extends" in node && Array.isArray(node.extends) ? node.extends : [];
+				for (const heritage of extendsClause) {
+					const expr = "expression" in heritage ? heritage.expression : null;
+					if (!expr || !("name" in expr) || expr.name !== "BindableProps") continue;
+					const typeParams = "typeArguments" in heritage && heritage.typeArguments ? heritage.typeArguments : "typeParameters" in heritage && heritage.typeParameters ? heritage.typeParameters : null;
+					const firstParam = (typeParams && typeof typeParams === "object" && "params" in typeParams ? typeParams.params : [])[0];
+					if (firstParam && typeof firstParam === "object" && firstParam !== null && "type" in firstParam) {
+						if (firstParam.type === "TSTypeReference") {
+							const refTypeName = firstParam.typeName?.name;
+							if (typeof refTypeName === "string") bindableTypeName = refTypeName;
+						} else if (firstParam.type === "TSTypeLiteral") aliasBindableTypes.push(firstParam);
+					}
+				}
+			}
+		}
 	} });
+	if (bindableTypeName && bindableProps.size === 0) {
+		const bindableAlias = typeAliasCache.get(bindableTypeName);
+		if (bindableAlias && bindableAlias.type === "TSTypeAliasDeclaration") {
+			const typeAnnotation = "typeAnnotation" in bindableAlias ? bindableAlias.typeAnnotation : null;
+			if (typeAnnotation) {
+				if (typeAnnotation.type === "TSTypeLiteral") extractPropNames(typeAnnotation, bindableProps);
+				else if (typeAnnotation.type === "TSTypeReference") {
+					const resolvedType = resolveTypeAliasCached(typeAnnotation, typeAliasCache);
+					if (resolvedType?.type === "TSTypeLiteral") extractPropNames(resolvedType, bindableProps);
+				}
+			}
+		}
+	}
 	return {
 		propsType,
 		bindableProps,
@@ -253,16 +293,27 @@ function resolveTypeAliasCached(type, typeAliasCache) {
 	if (!typeName) return null;
 	const aliasNode = typeAliasCache.get(typeName);
 	if (!aliasNode) return null;
+	if (aliasNode.type === "TSInterfaceDeclaration") {
+		const body = "body" in aliasNode ? aliasNode.body : null;
+		if (body && typeof body === "object" && "type" in body && body.type === "TSInterfaceBody") return body;
+		return null;
+	}
 	const typeAnnotation = "typeAnnotation" in aliasNode ? aliasNode.typeAnnotation : null;
 	if (typeAnnotation && "type" in typeAnnotation && typeAnnotation.type !== "TSTypeAnnotation") return typeAnnotation;
 	return null;
 }
 function collectTypeLiterals(type, typeAliasCache, collected) {
 	if (!type) return;
-	if (type.type === "TSTypeLiteral") {
+	const nodeType = type.type;
+	if (nodeType === "TSTypeLiteral" || nodeType === "TSInterfaceBody") {
 		collected.add(type);
 		return;
 	}
+	if (nodeType === "TSInterfaceDeclaration") {
+		const body = "body" in type ? type.body : null;
+		if (body && body.type === "TSInterfaceBody") collected.add(body);
+		return;
+	}
 	if (type.type === "TSIntersectionType" && "types" in type) {
 		for (const intersectionType of type.types) collectTypeLiterals(intersectionType, typeAliasCache, collected);
 		return;
@@ -289,6 +340,18 @@ function getTypeName(node) {
 	if (!("id" in node) || !("name" in node.id)) return "";
 	return node.id.name;
 }
+function getInterfaceName(node) {
+	if (node.type !== "TSInterfaceDeclaration") return "";
+	if (!("id" in node) || !("name" in node.id)) return "";
+	return node.id.name;
+}
+function getTypeMembers(node) {
+	if (!node || typeof node !== "object" || !("type" in node)) return [];
+	const typed = node;
+	const raw = typed.type === "TSInterfaceBody" ? typed.body : typed.members;
+	if (!Array.isArray(raw)) return [];
+	return raw.filter((m) => typeof m === "object" && m !== null && "type" in m && m.type === "TSPropertySignature");
+}
 function getTypeReferenceName(type) {
 	if (type.type !== "TSTypeReference") return "";
 	if (!("typeName" in type)) return "";
@@ -308,17 +371,13 @@ function getTypeParameters(type) {
 	return type.typeParameters.params;
 }
 function extractPropNames(typeLiteral, props) {
-	if (!("members" in typeLiteral)) return;
-	for (const member of typeLiteral.members) {
-		if (member.type !== "TSPropertySignature") continue;
+	for (const member of getTypeMembers(typeLiteral)) {
 		const key = getPropertyKey(member);
 		if (key) props.add(key);
 	}
 }
 function extractPropsFromType(typeLiteral, source, bindableProps, propsMap, typeAliasCache, forceBindable = false) {
-	if (!("members" in typeLiteral)) return;
-	for (const member of typeLiteral.members) {
-		if (member.type !== "TSPropertySignature") continue;
+	for (const member of getTypeMembers(typeLiteral)) {
 		const prop = extractPropFromSignature(member, source, bindableProps, typeAliasCache, forceBindable);
 		if (prop) {
 			const existing = propsMap.get(prop.name);

package/lib/playground/scenario-injection.qwik.mjs

@@ -1,23 +1,56 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { basename, dirname, extname, join } from "node:path";
 import { createRegExp, exactly, not } from "magic-regexp";
 import MagicString from "magic-string";
+import { parseSync } from "oxc-parser";
 import { walk } from "oxc-walker";
-import { existsSync, readdirSync, statSync } from "node:fs";
-import { basename, dirname, extname, join } from "node:path";
 import { remark } from "remark";
 import remarkMdx from "remark-mdx";
 
 //#region playground/scenario-injection.ts
+const SCENARIO_SOURCE_QUERY = "?scenario-source";
+function stripTypeAnnotations(filePath, source) {
+	const { program } = parseSync(filePath, source, { sourceType: "module" });
+	const s = new MagicString(source);
+	walk(program, { enter(node) {
+		const n = node;
+		if (n.type === "ImportDeclaration" && n.importKind === "type") {
+			let end = n.end;
+			if (source[end] === "\n") end++;
+			s.remove(n.start, end);
+			return;
+		}
+		if (n.type === "ImportSpecifier" && n.importKind === "type") {
+			const typePrefix = source.slice(n.start, n.end).indexOf("type ");
+			if (typePrefix !== -1) s.remove(n.start + typePrefix, n.start + typePrefix + 5);
+			return;
+		}
+		if (n.typeAnnotation) s.remove(n.typeAnnotation.start, n.typeAnnotation.end);
+	} });
+	return s.toString();
+}
 const scenarioInjection = () => {
 	const isMDX = createRegExp(exactly(".").and("mdx").at.lineEnd());
 	const sanitizePattern = createRegExp(not.wordChar, ["g"]);
 	return {
 		name: "vite-plugin-qds-playground-scenarios",
 		enforce: "pre",
+		resolveId(source, importer) {
+			if (!source.endsWith(SCENARIO_SOURCE_QUERY)) return;
+			const relativePath = source.slice(0, -16);
+			return `\0scenario-source:${importer ? join(dirname(importer), relativePath) : relativePath}`;
+		},
+		load(id) {
+			if (!id.startsWith("\0scenario-source:")) return;
+			const filePath = id.slice(17);
+			const stripped = stripTypeAnnotations(filePath, readFileSync(filePath, "utf-8"));
+			return `export default ${JSON.stringify(stripped)};`;
+		},
 		transform(code, id) {
 			if (!isMDX.test(id)) return;
 			try {
 				const mdast = remark().use(remarkMdx).parse(code);
-				const s = new MagicString(code);
+				const codeStr = new MagicString(code);
 				let hasPlayground = false;
 				const scenariosDir = join(dirname(id), "scenarios");
 				if (!existsSync(scenariosDir) || !statSync(scenariosDir).isDirectory()) return null;
@@ -38,23 +71,23 @@ const scenarioInjection = () => {
 							if (!mdxNode.attributes.some((attr) => attr.name === "scenarios")) {
 								const scenariosArrayString = `[${scenarioFiles.map((s) => `{name: "${s.name}", component: ${s.componentVar}, source: ${s.sourceVar}}`).join(", ")}]`;
 								const insertPos = mdxNode.position.start.offset + 11;
-								s.appendLeft(insertPos, ` scenarios={${scenariosArrayString}}`);
+								codeStr.appendLeft(insertPos, ` scenarios={${scenariosArrayString}}`);
 								hasPlayground = true;
 							}
 						}
 					}
 				} });
 				if (!hasPlayground) return null;
-				const imports = scenarioFiles.map((file) => `import ${file.componentVar} from "./scenarios/${file.file}";\nimport ${file.sourceVar} from "./scenarios/${file.file}?raw";`).join("\n");
+				const imports = scenarioFiles.map((file) => `import ${file.componentVar} from "./scenarios/${file.file}";\nimport ${file.sourceVar} from "./scenarios/${file.file}?scenario-source";`).join("\n");
 				let insertPos = 0;
 				if (code.startsWith("---")) {
 					const secondDelimiter = code.indexOf("---", 3);
 					if (secondDelimiter !== -1) insertPos = secondDelimiter + 3;
 				}
-				s.appendLeft(insertPos, `\n${imports}\n`);
+				codeStr.appendLeft(insertPos, `\n${imports}\n\n`);
 				return {
-					code: s.toString(),
-					map: s.generateMap({ hires: true })
+					code: codeStr.toString(),
+					map: codeStr.generateMap({ hires: true })
 				};
 			} catch (error) {
 				console.error(`Error transforming Playground in ${id}:`, error);

package/lib/rolldown/as-child.d.ts

@@ -1,15 +1,16 @@
+import type { Program } from "@oxc-project/types";
 import type { Plugin } from "rolldown";
+import MagicString from "magic-string";
 export type AsChildTypes = {
     asChild?: true;
 };
 export type AsChildPluginOptions = {
     debug?: boolean;
 };
-/**
- * Rolldown plugin that transforms JSX elements with asChild prop by moving child element props to the parent
- * @param options - Plugin configuration options
- * @returns Rolldown-compatible plugin object
- */
+export type AsChildTransformCoreResult = {
+    changed: boolean;
+};
+export declare function asChildTransformCore(ast: Program, s: MagicString, code: string, debug: (message: string) => void): AsChildTransformCoreResult;
 export declare const asChild: (options?: AsChildPluginOptions) => Plugin & {
     enforce?: "pre" | "post";
 };