@withstudiocms/component-registry 0.1.0-beta.1

package/dist/errors.d.ts

@@ -0,0 +1,76 @@
+import { AstroError } from 'astro/errors';
+export declare class ComponentProxyError extends AstroError {
+    message: string;
+    stack?: string;
+    name: string;
+    constructor(message: string, hint: string, stack?: string);
+}
+export declare function prefixError(err: Error, prefix: string): Error;
+declare const ComponentRegistryError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ComponentRegistryError";
+} & Readonly<A>;
+/**
+ * Error class representing issues related to the component registry.
+ *
+ * @remarks
+ * This error extends a tagged error type with the tag `'ComponentRegistryError'`.
+ *
+ * @example
+ * ```typescript
+ * throw new ComponentRegistryError({ message: "Component not found" });
+ * ```
+ *
+ * @property message - A descriptive error message.
+ * @property cause - (Optional) The underlying cause of the error, if any.
+ */
+export declare class ComponentRegistryError extends ComponentRegistryError_base<{
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const FileParseError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FileParseError";
+} & Readonly<A>;
+/**
+ * Error thrown when a file fails to parse.
+ *
+ * @remarks
+ * This error extends a tagged error type with the tag 'FileParseError'.
+ *
+ * @example
+ * ```typescript
+ * throw new FileParseError({ filePath: '/path/to/file', message: 'Invalid format' });
+ * ```
+ *
+ * @property filePath - The path of the file that failed to parse.
+ * @property message - A descriptive error message.
+ * @property cause - (Optional) The underlying cause of the error, if available.
+ */
+export declare class FileParseError extends FileParseError_base<{
+    readonly filePath: string;
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const ComponentNotFoundError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ComponentNotFoundError";
+} & Readonly<A>;
+/**
+ * Error thrown when a requested component cannot be found in the registry.
+ *
+ * @remarks
+ * This error extends a tagged error type with the tag 'ComponentNotFoundError'.
+ *
+ * @example
+ * ```typescript
+ * throw new ComponentNotFoundError({ componentName: 'MyComponent' });
+ * ```
+ *
+ * @property componentName - The name of the component that was not found.
+ */
+export declare class ComponentNotFoundError extends ComponentNotFoundError_base<{
+    readonly componentName: string;
+}> {
+}
+export declare function toComponentProxyError(err: Error, prefix: string): ComponentProxyError;
+export {};

package/dist/errors.js

@@ -0,0 +1,48 @@
+import { Data } from "@withstudiocms/effect";
+import { AstroError } from "astro/errors";
+class ComponentProxyError extends AstroError {
+  message;
+  stack;
+  name = "Component Proxy Error";
+  constructor(message, hint, stack) {
+    super(message, hint);
+    this.message = message;
+    this.hint = hint;
+    this.stack = stack;
+  }
+}
+function prefixError(err, prefix) {
+  if (err?.message) {
+    try {
+      err.message = `${prefix}:
+${err.message}`;
+      return err;
+    } catch {
+    }
+  }
+  const wrappedError = new Error(`${prefix}${err ? `: ${err}` : ""}`);
+  try {
+    wrappedError.stack = err.stack;
+    wrappedError.cause = err;
+  } catch {
+  }
+  return wrappedError;
+}
+class ComponentRegistryError extends Data.TaggedError("ComponentRegistryError") {
+}
+class FileParseError extends Data.TaggedError("FileParseError") {
+}
+class ComponentNotFoundError extends Data.TaggedError("ComponentNotFoundError") {
+}
+function toComponentProxyError(err, prefix) {
+  const wrapped = prefixError(err, prefix);
+  return new ComponentProxyError(wrapped.message, wrapped.message, wrapped.stack);
+}
+export {
+  ComponentNotFoundError,
+  ComponentProxyError,
+  ComponentRegistryError,
+  FileParseError,
+  prefixError,
+  toComponentProxyError
+};

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './component-proxy/index.js';
+export * from './errors.js';
+export * from './registry/index.js';
+export * from './transform-html.js';
+export * from './types.js';
+export * from './utils.js';

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from "./component-proxy/index.js";
+export * from "./errors.js";
+export * from "./registry/index.js";
+export * from "./transform-html.js";
+export * from "./types.js";
+export * from "./utils.js";

package/dist/registry/PropsParser.d.ts

@@ -0,0 +1,15 @@
+import { Effect } from '@withstudiocms/effect';
+import { ComponentRegistryError, FileParseError } from '../errors.js';
+import type { AstroComponentProps } from '../types.js';
+declare const PropsParser_base: Effect.Service.Class<PropsParser, "PropsParser", {
+    readonly effect: Effect.Effect<{
+        parseComponentProps: (sourceCode: string) => Effect.Effect<AstroComponentProps[], ComponentRegistryError, never>;
+        extractPropsFromAstroFile: (astroFileContent: string) => Effect.Effect<string, FileParseError, never>;
+    }, never, never>;
+}>;
+/**
+ * Service for parsing component props from TypeScript source code and extracting prop definitions from Astro files.
+ */
+export declare class PropsParser extends PropsParser_base {
+}
+export {};

package/dist/registry/PropsParser.js

@@ -0,0 +1,210 @@
+import { Effect } from "@withstudiocms/effect";
+import { Project, SyntaxKind } from "ts-morph";
+import { ComponentRegistryError, FileParseError } from "../errors.js";
+class PropsParser extends Effect.Service()("PropsParser", {
+  effect: Effect.gen(function* () {
+    return {
+      parseComponentProps: (sourceCode) => Effect.try({
+        try: () => {
+          const project = new Project();
+          const sourceFile = project.createSourceFile("temp.ts", sourceCode);
+          const results = [];
+          const extractJSDocInfo = (node) => {
+            const jsDocComments = node.getJsDocs();
+            let description;
+            let defaultValue;
+            const jsDocTags = [];
+            if (jsDocComments.length > 0) {
+              description = jsDocComments[0].getDescription().trim();
+              for (const jsDoc of jsDocComments) {
+                const tags = jsDoc.getTags();
+                for (const tag of tags) {
+                  const tagName = tag.getTagName();
+                  const commentText = tag.getCommentText();
+                  switch (tagName) {
+                    case "param": {
+                      const paramInfo = tag.getStructure();
+                      jsDocTags.push({
+                        tagName,
+                        text: commentText,
+                        name: paramInfo.tagName,
+                        type: typeof paramInfo.text === "string" ? paramInfo.text : void 0
+                      });
+                      break;
+                    }
+                    case "default": {
+                      defaultValue = commentText;
+                      jsDocTags.push({
+                        tagName,
+                        text: commentText
+                      });
+                      break;
+                    }
+                    case "example":
+                    case "since":
+                    case "deprecated":
+                    case "see":
+                    case "author":
+                    case "version":
+                    case "throws":
+                    case "returns":
+                    case "readonly":
+                    case "internal":
+                    case "beta":
+                    case "alpha":
+                    case "experimental": {
+                      jsDocTags.push({
+                        tagName,
+                        text: commentText
+                      });
+                      break;
+                    }
+                    default: {
+                      jsDocTags.push({
+                        tagName,
+                        text: commentText
+                      });
+                    }
+                  }
+                }
+              }
+            }
+            return { description, defaultValue, jsDocTags };
+          };
+          const interfaces = sourceFile.getInterfaces();
+          for (const interfaceDecl of interfaces) {
+            const interfaceName = interfaceDecl.getName();
+            const props = [];
+            const properties = interfaceDecl.getProperties();
+            for (const property of properties) {
+              const propName = property.getName();
+              const propType = property.getTypeNode()?.getText() || "unknown";
+              const isOptional = property.hasQuestionToken();
+              const { description, defaultValue, jsDocTags } = extractJSDocInfo(property);
+              props.push({
+                name: propName,
+                type: propType,
+                optional: isOptional,
+                description,
+                defaultValue,
+                jsDocTags: jsDocTags.length > 0 ? jsDocTags : void 0
+              });
+            }
+            results.push({ name: interfaceName, props });
+          }
+          const typeAliases = sourceFile.getTypeAliases();
+          for (const typeAlias of typeAliases) {
+            const typeName = typeAlias.getName();
+            const typeNode = typeAlias.getTypeNode();
+            if (typeNode && typeNode.getKind() === SyntaxKind.TypeLiteral) {
+              const props = [];
+              const typeLiteral = typeNode.asKindOrThrow(SyntaxKind.TypeLiteral);
+              const members = typeLiteral.getMembers();
+              for (const member of members) {
+                if (member.getKind() === SyntaxKind.PropertySignature) {
+                  const propSig = member.asKindOrThrow(SyntaxKind.PropertySignature);
+                  const propName = propSig.getName();
+                  const propType = propSig.getTypeNode()?.getText() || "unknown";
+                  const isOptional = propSig.hasQuestionToken();
+                  const { description, defaultValue, jsDocTags } = extractJSDocInfo(propSig);
+                  props.push({
+                    name: propName,
+                    type: propType,
+                    optional: isOptional,
+                    description,
+                    defaultValue,
+                    jsDocTags: jsDocTags.length > 0 ? jsDocTags : void 0
+                  });
+                }
+              }
+              results.push({ name: typeName, props });
+            } else {
+              console.log(
+                `Type alias ${typeName} is not a type literal, kind: ${typeNode?.getKindName()}`
+              );
+            }
+          }
+          return results;
+        },
+        catch: (error) => {
+          console.error("Error parsing component props:", error);
+          return new ComponentRegistryError({
+            message: "Failed to parse component props",
+            cause: error
+          });
+        }
+      }),
+      extractPropsFromAstroFile: (astroFileContent) => Effect.try({
+        try: () => {
+          const frontmatterMatch = astroFileContent.match(/^---\s*\n([\s\S]*?)\n---/m);
+          if (!frontmatterMatch) {
+            throw new Error("No frontmatter found in Astro file");
+          }
+          const frontmatter = frontmatterMatch[1];
+          const interfaceMatch = frontmatter.match(
+            /((?:export\s+)?interface\s+Props\s*\{[\s\S]*?\n\})/m
+          );
+          if (interfaceMatch) {
+            const propsDefinition2 = interfaceMatch[0].replace(/^export\s+/, "");
+            return propsDefinition2;
+          }
+          const typeMatch = frontmatter.match(
+            /((?:export\s+)?type\s+Props\s*=\s*\{[\s\S]*?\n\})/m
+          );
+          if (typeMatch) {
+            const propsDefinition2 = typeMatch[0].replace(/^export\s+/, "");
+            return propsDefinition2;
+          }
+          const propsStart = frontmatter.search(
+            /(?:export\s+)?(?:interface|type)\s+Props\s*[={]/
+          );
+          if (propsStart === -1) {
+            throw new Error("No Props interface or type found in frontmatter");
+          }
+          const propsSubstring = frontmatter.substring(propsStart);
+          let braceCount = 0;
+          let inString = false;
+          let stringChar = "";
+          let i = 0;
+          for (i = 0; i < propsSubstring.length; i++) {
+            const char = propsSubstring[i];
+            const prevChar = i > 0 ? propsSubstring[i - 1] : "";
+            if ((char === '"' || char === "'" || char === "`") && prevChar !== "\\") {
+              if (!inString) {
+                inString = true;
+                stringChar = char;
+              } else if (char === stringChar) {
+                inString = false;
+                stringChar = "";
+              }
+            }
+            if (!inString) {
+              if (char === "{") {
+                braceCount++;
+              } else if (char === "}") {
+                braceCount--;
+                if (braceCount === 0) {
+                  break;
+                }
+              }
+            }
+          }
+          const propsDefinition = propsSubstring.substring(0, i + 1).replace(/^export\s+/, "");
+          return propsDefinition;
+        },
+        catch: (error) => {
+          console.error("Error extracting props from Astro file:", error);
+          return new FileParseError({
+            filePath: "astro-content",
+            message: error instanceof Error ? error.message : "Failed to extract props from Astro file",
+            cause: error
+          });
+        }
+      })
+    };
+  })
+}) {
+}
+export {
+  PropsParser
+};

package/dist/registry/Registry.d.ts

@@ -0,0 +1,44 @@
+import { Effect, Layer, Platform } from '@withstudiocms/effect';
+import { ComponentNotFoundError, ComponentRegistryError, FileParseError } from '../errors.js';
+import type { AstroComponentProps } from '../types.js';
+import { PropsParser } from './PropsParser.js';
+declare const ComponentRegistry_base: Effect.Service.Class<ComponentRegistry, "ComponentRegistry", {
+    readonly dependencies: readonly [Layer.Layer<PropsParser, never, never>, Layer.Layer<Platform.Path.Path, never, never>, Layer.Layer<Platform.FileSystem.FileSystem, never, never>];
+    readonly effect: Effect.Effect<{
+        registerComponentFromFile: (filePath: string, componentName?: string) => Effect.Effect<void, ComponentRegistryError | FileParseError | Platform.Error.PlatformError, never>;
+        getAllComponents: () => Effect.Effect<Map<string, AstroComponentProps>, never, never>;
+        getComponentProps: (componentName: string) => Effect.Effect<AstroComponentProps, ComponentNotFoundError, never>;
+        validateProps: (componentName: string, props: Record<string, unknown>) => Effect.Effect<{
+            valid: boolean;
+            errors: string[];
+        }, ComponentNotFoundError, never>;
+    }, never, never>;
+}>;
+/**
+ * A service class for registering, retrieving, and validating Astro component props.
+ *
+ * The `ComponentRegistry` provides methods to:
+ * - Register a component and its props from an Astro file.
+ * - Retrieve the props definition for a registered component.
+ * - List all registered components and their props.
+ * - Validate a set of props against a registered component's prop definition.
+ *
+ * Dependencies:
+ * - `PropsParser.Default`: Used to extract and parse props from Astro files.
+ * - `Path.layer`: Used for file path operations.
+ * - `NodeFileSystem.layer`: Used for reading files from the filesystem.
+ *
+ * Methods:
+ * - `registerComponentFromFile(filePath: string, componentName?: string)`: Registers a component by reading and parsing its props from the specified Astro file.
+ * - `getComponentProps(componentName: string)`: Retrieves the props definition for the specified component.
+ * - `getAllComponents()`: Returns a map of all registered components and their props.
+ * - `validateProps(componentName: string, props: Record<string, unknown>)`: Validates the provided props against the registered component's prop definition, checking for missing required props and unknown props.
+ *
+ * Errors:
+ * - Throws `FileParseError` if the Astro file cannot be parsed.
+ * - Throws `ComponentRegistryError` if registration fails.
+ * - Throws `ComponentNotFoundError` if a requested component is not registered.
+ */
+export declare class ComponentRegistry extends ComponentRegistry_base {
+}
+export {};

package/dist/registry/Registry.js

@@ -0,0 +1,77 @@
+import { Effect, Layer, Platform, PlatformNode } from "@withstudiocms/effect";
+import { ComponentNotFoundError, ComponentRegistryError, FileParseError } from "../errors.js";
+import { PropsParser } from "./PropsParser.js";
+const registryDeps = Layer.mergeAll(
+  PropsParser.Default,
+  Platform.Path.layer,
+  PlatformNode.NodeFileSystem.layer
+);
+class ComponentRegistry extends Effect.Service()("ComponentRegistry", {
+  dependencies: [PropsParser.Default, Platform.Path.layer, PlatformNode.NodeFileSystem.layer],
+  effect: Effect.gen(function* () {
+    const parser = yield* PropsParser;
+    const fs = yield* Platform.FileSystem.FileSystem;
+    const path = yield* Platform.Path.Path;
+    const components = /* @__PURE__ */ new Map();
+    return {
+      registerComponentFromFile: (filePath, componentName) => Effect.gen(function* () {
+        const fileContent = yield* fs.readFileString(filePath);
+        const propsDefinition = yield* parser.extractPropsFromAstroFile(fileContent).pipe(
+          Effect.mapError(
+            (error) => new FileParseError({
+              filePath,
+              message: error.message,
+              cause: error.cause
+            })
+          )
+        );
+        const name = componentName || path.basename(filePath, path.extname(filePath));
+        const parsed = yield* parser.parseComponentProps(propsDefinition).pipe(
+          Effect.mapError(
+            (error) => new ComponentRegistryError({
+              message: `Failed to register component ${name}`,
+              cause: error
+            })
+          )
+        );
+        if (parsed.length > 0) {
+          components.set(name, parsed[0]);
+        }
+      }),
+      getAllComponents: () => Effect.succeed(new Map(components)),
+      getComponentProps: (componentName) => Effect.gen(function* () {
+        const component = components.get(componentName);
+        if (!component) {
+          return yield* Effect.fail(new ComponentNotFoundError({ componentName }));
+        }
+        return component;
+      }),
+      validateProps: (componentName, props) => Effect.gen(function* () {
+        const component = components.get(componentName);
+        if (!component) {
+          return yield* Effect.fail(new ComponentNotFoundError({ componentName }));
+        }
+        const errors = [];
+        const providedProps = new Set(Object.keys(props));
+        if (component) {
+          for (const prop of component.props) {
+            if (!prop.optional && !providedProps.has(prop.name)) {
+              errors.push(`Required prop "${prop.name}" is missing`);
+            }
+          }
+          const validPropNames = new Set(component.props.map((p) => p.name));
+          for (const propName of providedProps) {
+            if (!validPropNames.has(propName)) {
+              errors.push(`Unknown prop "${propName}"`);
+            }
+          }
+        }
+        return { valid: errors.length === 0, errors };
+      })
+    };
+  }).pipe(Effect.provide(registryDeps))
+}) {
+}
+export {
+  ComponentRegistry
+};

package/dist/registry/consts.d.ts

@@ -0,0 +1,42 @@
+import type { ComponentRegistryEntry } from '../types.js';
+/**
+ * Internal virtual module ID for the component registry.
+ */
+export declare const InternalId = "virtual:component-registry-internal-proxy";
+/**
+ * Runtime virtual module ID for the component registry.
+ */
+export declare const RuntimeInternalId = "virtual:component-registry-internal-proxy/runtime";
+/**
+ * Internal virtual module ID for the component registry.
+ */
+export declare const NameInternalId = "virtual:component-registry-internal-proxy/name";
+/**
+ * Builds a virtual import string that exports component keys, component props, and component definitions.
+ *
+ * @param componentKeys - An array of strings representing the keys of the components to be registered.
+ * @param componentProps - An array of `ComponentRegistryEntry` objects containing the props for each component.
+ * @param components - An array of strings, each representing a component's code to be included in the export.
+ * @returns A string containing the virtual import code that exports the component keys, props, and component definitions.
+ */
+export declare const buildVirtualImport: (componentKeys: string[], componentProps: ComponentRegistryEntry[], components: string[]) => string;
+/**
+ * Builds an object mapping virtual module IDs to their corresponding export statements.
+ *
+ * @param virtualId - The base virtual module ID to use as the key.
+ * @returns An object where:
+ *   - The key `virtualId` maps to an export statement for `InternalId`.
+ *   - The key `${virtualId}/runtime` maps to an export statement for `RuntimeInternalId`.
+ *
+ * @example
+ * ```typescript
+ * const exports = buildAliasExports('my-module');
+ * // {
+ * //   'my-module': "export * from 'InternalId';",
+ * //   'my-module/runtime': "export * from 'RuntimeInternalId';"
+ * // }
+ * ```
+ */
+export declare const buildAliasExports: (virtualId: string) => {
+    [x: string]: string;
+};

package/dist/registry/consts.js

@@ -0,0 +1,19 @@
+const InternalId = "virtual:component-registry-internal-proxy";
+const RuntimeInternalId = `${InternalId}/runtime`;
+const NameInternalId = `${InternalId}/name`;
+const buildVirtualImport = (componentKeys, componentProps, components) => `
+export const componentKeys = ${JSON.stringify(componentKeys)};
+export const componentProps = ${JSON.stringify(componentProps)};
+${components ? components.join("\n") : ""}
+`;
+const buildAliasExports = (virtualId) => ({
+  [virtualId]: `export * from '${InternalId}';`,
+  [`${virtualId}/runtime`]: `export * from '${RuntimeInternalId}';`
+});
+export {
+  InternalId,
+  NameInternalId,
+  RuntimeInternalId,
+  buildAliasExports,
+  buildVirtualImport
+};

package/dist/registry/handler.d.ts

@@ -0,0 +1,92 @@
+/// <reference types="../virtual.d.ts" preserve="true" />
+import { z } from 'astro/zod';
+export declare const ComponentRegistryHandlerOptionSchema: z.ZodObject<{
+    config: z.ZodObject<{
+        /**
+         * The name of the integration
+         */
+        name: z.ZodString;
+        /**
+         * The virtual module ID for generated imports
+         *
+         * @example 'virtual:my-integration'
+         */
+        virtualId: z.ZodOptional<z.ZodString>;
+        /**
+         * Enables verbose logging
+         */
+        verbose: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        verbose?: boolean | undefined;
+        virtualId?: string | undefined;
+    }, {
+        name: string;
+        verbose?: boolean | undefined;
+        virtualId?: string | undefined;
+    }>;
+    /**
+     * A record of user-provided component names to file paths.
+     */
+    componentRegistry: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    /**
+     * A record of built-in component names to file paths.
+     */
+    builtInComponents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    config: {
+        name: string;
+        verbose?: boolean | undefined;
+        virtualId?: string | undefined;
+    };
+    componentRegistry?: Record<string, string> | undefined;
+    builtInComponents?: Record<string, string> | undefined;
+}, {
+    config: {
+        name: string;
+        verbose?: boolean | undefined;
+        virtualId?: string | undefined;
+    };
+    componentRegistry?: Record<string, string> | undefined;
+    builtInComponents?: Record<string, string> | undefined;
+}>;
+export type ComponentRegistryHandlerOptions = z.infer<typeof ComponentRegistryHandlerOptionSchema>;
+/**
+ * Handles the setup and registration of components in the component registry during the Astro config setup phase.
+ *
+ * This utility merges built-in and user-provided component registries, validates and resolves component paths,
+ * registers components, and generates virtual imports for use at runtime. It also logs detailed information
+ * about the registration process, including the number of components processed and their properties.
+ *
+ * @remarks
+ * - Only components with string values ending in `.astro` are considered valid.
+ * - Uses Effect for error handling and asynchronous operations.
+ * - Generates virtual modules for internal proxying and runtime usage.
+ *
+ * @param params - The parameters provided by the Astro utility hook, including logger and config.
+ * @param options - An object containing configuration and registry options:
+ *   - `config.verbose` - Enables verbose logging if true.
+ *   - `config.name` - The name of the integration for logging purposes.
+ *   - `config.virtualId` - The virtual module ID for generated imports.
+ *   - `builtInComponents` - A record of built-in component names to file paths.
+ *   - `componentRegistry` - A record of user-provided component names to file paths.
+ * @returns A promise that resolves after the component registry has been set up and virtual imports have been added.
+ *
+ * @example
+ * ```typescript
+ * await componentRegistryHandler(params, {
+ *   config: { verbose: true, name: 'my-integration', virtualId: 'virtual:my-registry' },
+ *   builtInComponents: { button: '/components/Button.astro' },
+ *   componentRegistry: { card: '/components/Card.astro' }
+ * });
+ * ```
+ */
+export declare const componentRegistryHandler: import("astro-integration-kit").HookUtility<"astro:config:setup", [{
+    config: {
+        name: string;
+        verbose?: boolean | undefined;
+        virtualId?: string | undefined;
+    };
+    componentRegistry?: Record<string, string> | undefined;
+    builtInComponents?: Record<string, string> | undefined;
+}], Promise<void>>;