@ic-reactor/codegen 0.11.1 → 0.12.0

package/README.md

@@ -54,16 +54,17 @@ need to skip `index.generated.ts` and `index.ts`.
 
 You can also use individual generators if you need more granular control:
 
-- **`generateDeclarations`**: Generates `.js` (factory), `.d.ts` (types), and `.did` copy.
-- **`generateReactorFile`**: Generates the managed `index.generated.ts` implementation using either `DisplayReactor` or `Reactor`.
+- **`generateDeclarations`**: Writes `declarations/<did-basename>.js` (factory), `.d.ts` (types), and a `.did` copy. The `declarations/` directory is wiped and recreated on every run.
+- **`generateReactorFile`**: Generates the managed `index.generated.ts` implementation using any `ReactorClassName` — `Reactor`, `DisplayReactor` (default), `CandidReactor`, `CandidDisplayReactor`, or `MetadataDisplayReactor`. With `target: "react"` it also emits the six `createActorHooks` exports (`use<Canister>Query`, `use<Canister>SuspenseQuery`, `use<Canister>InfiniteQuery`, `use<Canister>SuspenseInfiniteQuery`, `use<Canister>Mutation`, `use<Canister>Method`). No `createQuery` / `createMutation` objects are generated.
 - **`generateReactorEntryFile`**: Generates the stable `index.ts` wrapper that re-exports from `index.generated.ts`.
 - **`generateClientFile`**: Generates a `ClientManager` boilerplate file that
   imports `ClientManager` from `@ic-reactor/react`.
 
 ## Utilities
 
-- **`parseDIDFile`**: Parses a `.did` file and extracts method signatures.
-- **`toPascalCase` / `toCamelCase`**: Naming helpers.
+- **`parseDIDFile` / `extractMethods`**: Parse a `.did` file and extract method signatures.
+- **`toPascalCase` / `getReactorName` / `getServiceTypeName`**: Naming helpers.
+- **`generateCodecDeclarations`**: Renders a `@ic-reactor/cod` codec module from Candid (also available on the `./renderer` subpath).
 
 ## License
 

package/dist/chunk-VBCR5IVT.js

@@ -0,0 +1,609 @@
+// src/metadata-rules.json
+var metadata_rules_default = {
+  defaultValidationMessages: {
+    minimum: {
+      template: "Must be at least {value}"
+    },
+    maximum: {
+      template: "Must be at most {value}"
+    },
+    minLength: {
+      template: "Must be at least {value} character{plural}"
+    },
+    maxLength: {
+      template: "Must be at most {value} character{plural}"
+    }
+  },
+  email: {
+    helper: "email",
+    regex: "^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$",
+    jsonSchemaFormat: "email",
+    errorMessage: "Must be a valid email address"
+  },
+  "date-time": {
+    helper: "dateTime",
+    regex: "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|[+-](?:[01]\\d|2[0-3]):[0-5]\\d))$",
+    jsonSchemaFormat: "date-time",
+    errorMessage: "Must be a valid ISO datetime"
+  },
+  datetime: {
+    helper: "datetime",
+    regex: "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|[+-](?:[01]\\d|2[0-3]):[0-5]\\d))$",
+    jsonSchemaFormat: "date-time",
+    errorMessage: "Must be a valid ISO datetime"
+  },
+  date: {
+    helper: "date",
+    regex: "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))$",
+    jsonSchemaFormat: "date",
+    errorMessage: "Must be a valid ISO date"
+  },
+  time: {
+    helper: "time",
+    regex: "^(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?$",
+    errorMessage: "Must be a valid ISO time"
+  },
+  duration: {
+    helper: "duration",
+    regex: "^P(?:(\\d+W)|(?!.*W)(?=\\d|T\\d)(\\d+Y)?(\\d+M)?(\\d+D)?(T(?=\\d)(\\d+H)?(\\d+M)?(\\d+([.,]\\d+)?S)?)?)$",
+    jsonSchemaFormat: "duration",
+    errorMessage: "Must be a valid ISO duration"
+  },
+  url: {
+    helper: "url",
+    regex: "^[a-zA-Z][a-zA-Z\\d+.-]*:.+",
+    jsonSchemaFormat: "uri",
+    errorMessage: "Must be a valid URL"
+  },
+  uri: {
+    helper: "uri",
+    regex: "^[a-zA-Z][a-zA-Z\\d+.-]*:.+",
+    jsonSchemaFormat: "uri",
+    errorMessage: "Must be a valid URI"
+  },
+  httpsUrl: {
+    helper: "httpsUrl",
+    regex: "^https://.+",
+    jsonSchemaFormat: "uri",
+    errorMessage: "Must be a valid HTTPS URL"
+  },
+  ipv4: {
+    helper: "ipv4",
+    regex: "^(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.|$)){4}$",
+    jsonSchemaFormat: "ipv4",
+    errorMessage: "Must be a valid IPv4 address"
+  },
+  ipv6: {
+    helper: "ipv6",
+    regex: "^((?:[0-9A-Fa-f]{1,4}:){7}[0-9A-Fa-f]{1,4}|::1|::|(?:[0-9A-Fa-f]{1,4}:){1,7}:|(?:[0-9A-Fa-f]{1,4}:){1,6}:[0-9A-Fa-f]{1,4}|(?:[0-9A-Fa-f]{1,4}:){1,5}(?::[0-9A-Fa-f]{1,4}){1,2}|(?:[0-9A-Fa-f]{1,4}:){1,4}(?::[0-9A-Fa-f]{1,4}){1,3}|(?:[0-9A-Fa-f]{1,4}:){1,3}(?::[0-9A-Fa-f]{1,4}){1,4}|(?:[0-9A-Fa-f]{1,4}:){1,2}(?::[0-9A-Fa-f]{1,4}){1,5}|[0-9A-Fa-f]{1,4}:(?:(?::[0-9A-Fa-f]{1,4}){1,6}))$",
+    jsonSchemaFormat: "ipv6",
+    errorMessage: "Must be a valid IPv6 address"
+  },
+  uuid: {
+    helper: "uuid",
+    regex: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$",
+    jsonSchemaFormat: "uuid",
+    errorMessage: "Must be a valid UUID"
+  },
+  guid: {
+    helper: "guid",
+    regex: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$",
+    jsonSchemaFormat: "uuid",
+    errorMessage: "Must be a valid GUID"
+  },
+  base64: {
+    helper: "base64",
+    regex: "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
+    contentEncoding: "base64",
+    errorMessage: "Must be valid base64"
+  },
+  base64url: {
+    helper: "base64url",
+    regex: "^[A-Za-z0-9_-]+$",
+    errorMessage: "Must be valid base64url"
+  },
+  cuid: {
+    helper: "cuid",
+    regex: "^c[a-z0-9]{24}$",
+    errorMessage: "Must be a valid CUID"
+  },
+  cuid2: {
+    helper: "cuid2",
+    regex: "^[a-z][a-z0-9]*$",
+    errorMessage: "Must be a valid CUID2"
+  },
+  ulid: {
+    helper: "ulid",
+    regex: "^[0-9A-HJKMNP-TV-Z]{26}$",
+    errorMessage: "Must be a valid ULID"
+  },
+  nanoid: {
+    helper: "nanoid",
+    regex: "^[A-Za-z0-9_-]{21}$",
+    errorMessage: "Must be a valid nanoid"
+  },
+  emoji: {
+    helper: "emoji",
+    regex: "^\\p{Extended_Pictographic}+$",
+    errorMessage: "Must contain only emoji characters"
+  },
+  cidrv4: {
+    helper: "cidrv4",
+    regex: "^(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)/(?:3[0-2]|[12]?\\d)$",
+    errorMessage: "Must be a valid IPv4 CIDR range"
+  },
+  cidrv6: {
+    helper: "cidrv6",
+    regex: "^[0-9A-Fa-f:]+/(?:12[0-8]|1[01]\\d|\\d?\\d)$",
+    errorMessage: "Must be a valid IPv6 CIDR range"
+  },
+  mac: {
+    helper: "mac",
+    regex: "^(?:[0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$",
+    errorMessage: "Must be a valid MAC address"
+  }
+};
+
+// src/metadata.ts
+var metadataRulesFile = metadata_rules_default;
+var defaultValidationMessages = metadataRulesFile.defaultValidationMessages ?? {};
+var rawRuleEntries = Object.entries(metadata_rules_default).filter(
+  ([type]) => type !== "defaultValidationMessages"
+);
+var BUILT_IN_JSDOC_FORMAT_TYPES = Object.fromEntries(
+  rawRuleEntries.map(([type, rule]) => [
+    type,
+    {
+      regex: rule.regex,
+      jsonSchemaFormat: rule.jsonSchemaFormat,
+      contentEncoding: rule.contentEncoding,
+      errorMessage: rule.errorMessage
+    }
+  ])
+);
+var BUILT_IN_FORMAT_HELPERS = Object.fromEntries(
+  rawRuleEntries.filter(([, rule]) => rule.helper).map(([type, rule]) => [type, rule.helper])
+);
+function normalizeFormatDefinition(definition) {
+  if (!definition) return void 0;
+  return typeof definition === "string" ? { regex: definition } : definition;
+}
+function formatDefinitionFor(type, options) {
+  const builtIn = BUILT_IN_JSDOC_FORMAT_TYPES[type];
+  const custom = normalizeFormatDefinition(
+    options.customJSDocFormatTypes?.[type]
+  );
+  if (!custom) return builtIn;
+  return {
+    ...builtIn,
+    ...custom,
+    errorMessage: custom.errorMessage ?? builtIn?.errorMessage
+  };
+}
+function stripUndefined(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, entry]) => entry !== void 0)
+  );
+}
+function defaultBoundMessage(kind, value) {
+  const template = defaultValidationMessages[kind]?.template ?? (kind === "minimum" ? "Must be at least {value}" : kind === "maximum" ? "Must be at most {value}" : kind === "minLength" ? "Must be at least {value} character{plural}" : "Must be at most {value} character{plural}");
+  return template.replace("{value}", value).replace("{plural}", value === "1" ? "" : "s");
+}
+function withDefaultBoundMessage(bound, kind) {
+  if (!bound || bound.message !== void 0) return bound;
+  return {
+    ...bound,
+    message: defaultBoundMessage(kind, bound.value)
+  };
+}
+function normalizeValidationMetadata(validation, options) {
+  const normalized = {
+    ...validation,
+    minimum: withDefaultBoundMessage(validation.minimum, "minimum"),
+    maximum: withDefaultBoundMessage(validation.maximum, "maximum"),
+    minLength: withDefaultBoundMessage(validation.minLength, "minLength"),
+    maxLength: withDefaultBoundMessage(validation.maxLength, "maxLength")
+  };
+  const format = validation.format;
+  const formatDefinition = format ? formatDefinitionFor(format.type, options) : void 0;
+  if (format && formatDefinition) {
+    normalized.format = stripUndefined({
+      ...format,
+      regex: formatDefinition.regex,
+      jsonSchemaFormat: formatDefinition.jsonSchemaFormat,
+      contentEncoding: formatDefinition.contentEncoding,
+      errorMessage: format.message ?? formatDefinition.errorMessage
+    });
+  } else if (format) {
+    normalized.format = format;
+  }
+  return normalized;
+}
+
+// src/renderer.ts
+var reservedWords = /* @__PURE__ */ new Set([
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "import",
+  "in",
+  "instanceof",
+  "new",
+  "null",
+  "return",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield",
+  "let",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "static"
+]);
+function isValidIdentifier(name) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) && !reservedWords.has(name);
+}
+function assertIdentifier(name, label) {
+  if (!isValidIdentifier(name)) {
+    throw new Error(`${label} must be a valid TypeScript identifier: ${name}`);
+  }
+}
+function propertyName(name) {
+  return isValidIdentifier(name) ? name : JSON.stringify(name);
+}
+function normalizeOptions(options = {}) {
+  return typeof options === "string" ? { serviceExportName: options } : options;
+}
+function toServiceExportName(canisterName) {
+  return canisterName.replace(/[-\s]+/g, "_").toUpperCase();
+}
+function resolveServiceExportName(options, declaredTypeNames) {
+  if (options.serviceExportName) return options.serviceExportName;
+  if (options.canisterName) {
+    let name = toServiceExportName(options.canisterName);
+    if (declaredTypeNames.has(name)) {
+      name = `${name}_SERVICE`;
+    }
+    return name;
+  }
+  return "_SERVICE";
+}
+function hasMetadata(metadata) {
+  return metadata != null && Object.keys(metadata).length > 0;
+}
+function stripUndefined2(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, entry]) => entry !== void 0)
+  );
+}
+function isEmptyObject(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0;
+}
+function textFormatHelperFor(expression, metadata, options) {
+  const format = metadata.validation?.format;
+  if (!format || expression !== "c.text()") return void 0;
+  if (options.customJSDocFormatTypes?.[format.type]) {
+    return void 0;
+  }
+  return BUILT_IN_FORMAT_HELPERS[format.type];
+}
+function hasOnlyDescriptionDocs(docs, description) {
+  return docs != null && description != null && docs.length === 1 && docs[0] === description;
+}
+function metadataForRender(metadata, options) {
+  if (!metadata.validation) {
+    return metadata;
+  }
+  return {
+    ...metadata,
+    validation: normalizeValidationMetadata(metadata.validation, {
+      customJSDocFormatTypes: options.customJSDocFormatTypes
+    })
+  };
+}
+function applyMetadata(expression, metadata, options) {
+  if (!hasMetadata(metadata)) return expression;
+  const textFormatHelper = textFormatHelperFor(expression, metadata, options);
+  const textFormatMessage = metadata.validation?.format?.message;
+  const renderedMetadata = metadataForRender(metadata, options);
+  const { description, ...metadataRest } = renderedMetadata;
+  const rest = { ...metadataRest };
+  let result = textFormatHelper ? `c.${textFormatHelper}(${textFormatMessage ? JSON.stringify(textFormatMessage) : ""})` : expression;
+  if (textFormatHelper) {
+    delete rest.docs;
+    if (rest.validation) {
+      const { format: _format, ...validationRest } = rest.validation;
+      rest.validation = stripUndefined2(validationRest);
+      if (isEmptyObject(rest.validation)) {
+        delete rest.validation;
+      }
+    }
+  } else if (hasOnlyDescriptionDocs(rest.docs, description)) {
+    delete rest.docs;
+  }
+  if (description) {
+    result += `.describe(${JSON.stringify(description)})`;
+  }
+  if (Object.keys(rest).length > 0) {
+    result += `.meta(${JSON.stringify(rest)})`;
+  }
+  return result;
+}
+function getReferencedNames(type) {
+  const refs = [];
+  function visit(node) {
+    switch (node.kind) {
+      case "reference":
+        refs.push(node.name);
+        break;
+      case "opt":
+      case "vec":
+        visit(node.type);
+        break;
+      case "record":
+      case "variant":
+        for (const field of node.fields) {
+          visit(field.type);
+        }
+        break;
+      case "tuple":
+        for (const item of node.types) {
+          visit(item);
+        }
+        break;
+    }
+  }
+  visit(type);
+  return refs;
+}
+function sortDeclarations(declarations) {
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = [];
+  const declarationByName = new Map(
+    declarations.map((decl) => [decl.name, decl])
+  );
+  function visit(name) {
+    if (visited.has(name)) return;
+    const cycleStart = visiting.indexOf(name);
+    if (cycleStart !== -1) {
+      const cycle = [...visiting.slice(cycleStart), name].join(" -> ");
+      throw new Error(`Recursive Candid types are not supported yet: ${cycle}`);
+    }
+    const declaration = declarationByName.get(name);
+    if (!declaration) return;
+    visiting.push(name);
+    for (const dependency of getReferencedNames(declaration.type)) {
+      visit(dependency);
+    }
+    visiting.pop();
+    visited.add(name);
+    sorted.push(declaration);
+  }
+  for (const declaration of declarations) {
+    visit(declaration.name);
+  }
+  return sorted;
+}
+function renderType(type, indent = "", options = {}) {
+  const nextIndent = `${indent}  `;
+  let expression;
+  switch (type.kind) {
+    case "null":
+      expression = "c.null()";
+      break;
+    case "bool":
+      expression = "c.bool()";
+      break;
+    case "nat":
+      expression = "c.nat()";
+      break;
+    case "int":
+      expression = "c.int()";
+      break;
+    case "nat8":
+      expression = "c.nat8()";
+      break;
+    case "nat16":
+      expression = "c.nat16()";
+      break;
+    case "nat32":
+      expression = "c.nat32()";
+      break;
+    case "nat64":
+      expression = "c.nat64()";
+      break;
+    case "int8":
+      expression = "c.int8()";
+      break;
+    case "int16":
+      expression = "c.int16()";
+      break;
+    case "int32":
+      expression = "c.int32()";
+      break;
+    case "int64":
+      expression = "c.int64()";
+      break;
+    case "float32":
+      expression = "c.float32()";
+      break;
+    case "float64":
+      expression = "c.float64()";
+      break;
+    case "text":
+      expression = "c.text()";
+      break;
+    case "reserved":
+      expression = "c.reserved()";
+      break;
+    case "empty":
+      expression = "c.empty()";
+      break;
+    case "principal":
+      expression = "c.principal()";
+      break;
+    case "blob":
+      expression = "c.blob()";
+      break;
+    case "reference":
+      assertIdentifier(type.name, "Type reference");
+      expression = type.name;
+      break;
+    case "opt":
+      expression = `c.opt(${renderType(type.type, indent, options)})`;
+      break;
+    case "vec":
+      expression = `c.vec(${renderType(type.type, indent, options)})`;
+      break;
+    case "record": {
+      if (type.fields.length === 0) {
+        expression = "c.record({})";
+      } else {
+        const fields = type.fields.map((field) => {
+          const fieldExpression = applyMetadata(
+            renderType(field.type, nextIndent, options),
+            field.metadata,
+            options
+          );
+          return `${nextIndent}${propertyName(field.name)}: ${fieldExpression},`;
+        }).join("\n");
+        expression = `c.record({
+${fields}
+${indent}})`;
+      }
+      break;
+    }
+    case "variant": {
+      if (type.fields.length === 0) {
+        expression = "c.variant({})";
+      } else {
+        const fields = type.fields.map((field) => {
+          const fieldExpression = applyMetadata(
+            renderType(field.type, nextIndent, options),
+            field.metadata,
+            options
+          );
+          return `${nextIndent}${propertyName(field.name)}: ${fieldExpression},`;
+        }).join("\n");
+        expression = `c.variant({
+${fields}
+${indent}})`;
+      }
+      break;
+    }
+    case "tuple":
+      expression = `c.tuple([${type.types.map((item) => renderType(item, indent, options)).join(", ")}])`;
+      break;
+    case "func":
+    case "service":
+    case "class":
+    case "unknown":
+    case "knot":
+    case "future":
+      expression = `/* c.${type.kind} is not supported */ c.reserved()`;
+      break;
+  }
+  return applyMetadata(expression, type.metadata, options);
+}
+function renderMethodReturn(method, options) {
+  if (method.mode === "oneway") return "";
+  if (method.returns.length === 0) return "";
+  if (method.returns.length === 1) {
+    return `, ${renderType(method.returns[0], "    ", options)}`;
+  }
+  return `, [${method.returns.map((returnType) => renderType(returnType, "    ", options)).join(", ")}]`;
+}
+function generateCodecDeclarations(schema, optionsOrServiceExportName = {}) {
+  const options = normalizeOptions(optionsOrServiceExportName);
+  const lines = ['import { c } from "@ic-reactor/cod"', ""];
+  for (const declaration of sortDeclarations(schema.types)) {
+    assertIdentifier(declaration.name, "Type declaration name");
+    lines.push(
+      `export const ${declaration.name} = ${applyMetadata(
+        renderType(declaration.type, "", options),
+        declaration.metadata,
+        options
+      )}`
+    );
+    lines.push(
+      `export type ${declaration.name} = c.infer<typeof ${declaration.name}>`
+    );
+    lines.push("");
+  }
+  if (schema.service) {
+    const includeCompatibilityExports = options.includeCompatibilityExports ?? false;
+    const declaredTypeNames = new Set(schema.types.map((t) => t.name));
+    const serviceExportName = resolveServiceExportName(
+      options,
+      declaredTypeNames
+    );
+    assertIdentifier(serviceExportName, "Service export name");
+    const methods = schema.service.methods.map((method) => {
+      const args = method.args.map((arg) => renderType(arg, "    ", options)).join(", ");
+      const methodExpression = `c.${method.mode}([${args}]${renderMethodReturn(
+        method,
+        options
+      )})`;
+      return `  ${propertyName(method.name)}: ${applyMetadata(
+        methodExpression,
+        method.metadata,
+        options
+      )},`;
+    }).join("\n");
+    const serviceExpression = methods.length > 0 ? `c.service({
+${methods}
+})` : "c.service({})";
+    lines.push(
+      `export const ${serviceExportName} = ${applyMetadata(
+        serviceExpression,
+        schema.service.metadata,
+        options
+      )}`
+    );
+    lines.push("");
+    if (includeCompatibilityExports) {
+      lines.push(`export const idlFactory = ${serviceExportName}.idlFactory`);
+      lines.push(
+        `export type _SERVICE = c.ServiceOf<typeof ${serviceExportName}>`
+      );
+      lines.push("");
+      lines.push(`export const manifest = ${serviceExportName}.manifest()`);
+    }
+  }
+  return `${lines.join("\n").trimEnd()}
+`;
+}
+
+export {
+  BUILT_IN_JSDOC_FORMAT_TYPES,
+  BUILT_IN_FORMAT_HELPERS,
+  sortDeclarations,
+  renderType,
+  generateCodecDeclarations
+};