@ic-reactor/codegen 0.12.0 → 0.12.1

package/dist/renderer.js

@@ -1,14 +0,0 @@
-import {
-  BUILT_IN_FORMAT_HELPERS,
-  BUILT_IN_JSDOC_FORMAT_TYPES,
-  generateCodecDeclarations,
-  renderType,
-  sortDeclarations
-} from "./chunk-VBCR5IVT.js";
-export {
-  BUILT_IN_FORMAT_HELPERS,
-  BUILT_IN_JSDOC_FORMAT_TYPES,
-  generateCodecDeclarations,
-  renderType,
-  sortDeclarations
-};

package/src/metadata-rules.json

@@ -1,144 +0,0 @@
-{
-  "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"
-  }
-}

package/src/metadata.ts

@@ -1,157 +0,0 @@
-import type { CandidMetadata } from "@ic-reactor/parser"
-import metadataRules from "./metadata-rules.json"
-
-export type JSDocFormatDefinition = {
-  regex?: string
-  errorMessage?: string
-  jsonSchemaFormat?: string
-  contentEncoding?: string
-}
-
-export type CustomJSDocFormatTypes = Record<
-  string,
-  string | JSDocFormatDefinition
->
-
-type ValidationBoundRule = {
-  template?: string
-}
-
-type MetadataRulesFile = {
-  defaultValidationMessages?: Record<string, ValidationBoundRule>
-}
-
-const metadataRulesFile = metadataRules as MetadataRulesFile
-const defaultValidationMessages =
-  metadataRulesFile.defaultValidationMessages ?? {}
-
-const rawRuleEntries = Object.entries(metadataRules).filter(
-  ([type]) => type !== "defaultValidationMessages"
-) as Array<
-  [
-    string,
-    {
-      helper?: string
-      regex?: string
-      jsonSchemaFormat?: string
-      contentEncoding?: string
-      errorMessage?: string
-    },
-  ]
->
-
-export const BUILT_IN_JSDOC_FORMAT_TYPES: Readonly<
-  Record<string, JSDocFormatDefinition>
-> = Object.fromEntries(
-  rawRuleEntries.map(([type, rule]) => [
-    type,
-    {
-      regex: rule.regex,
-      jsonSchemaFormat: rule.jsonSchemaFormat,
-      contentEncoding: rule.contentEncoding,
-      errorMessage: rule.errorMessage,
-    },
-  ])
-) as Record<string, JSDocFormatDefinition>
-
-export const BUILT_IN_FORMAT_HELPERS: Readonly<Record<string, string>> =
-  Object.fromEntries(
-    rawRuleEntries
-      .filter(([, rule]) => rule.helper)
-      .map(([type, rule]) => [type, rule.helper as string])
-  )
-
-export interface FormatResolutionOptions {
-  customJSDocFormatTypes?: CustomJSDocFormatTypes
-}
-
-export function normalizeFormatDefinition(
-  definition: CustomJSDocFormatTypes[string] | undefined
-): JSDocFormatDefinition | undefined {
-  if (!definition) return undefined
-  return typeof definition === "string" ? { regex: definition } : definition
-}
-
-export function formatDefinitionFor(
-  type: string,
-  options: FormatResolutionOptions
-): JSDocFormatDefinition | undefined {
-  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<T extends Record<string, unknown>>(value: T): T {
-  return Object.fromEntries(
-    Object.entries(value).filter(([, entry]) => entry !== undefined)
-  ) as T
-}
-
-function defaultBoundMessage(
-  kind: "minimum" | "maximum" | "minLength" | "maxLength",
-  value: string
-): string {
-  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<
-  T extends { value: string; message?: string } | undefined,
->(bound: T, kind: "minimum" | "maximum" | "minLength" | "maxLength"): T {
-  if (!bound || bound.message !== undefined) return bound
-  return {
-    ...bound,
-    message: defaultBoundMessage(kind, bound.value),
-  } as T
-}
-
-export function normalizeValidationMetadata(
-  validation: NonNullable<CandidMetadata["validation"]>,
-  options: FormatResolutionOptions
-): NonNullable<CandidMetadata["validation"]> {
-  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)
-    : undefined
-
-  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
-}