@tsed/schema 8.9.5 → 8.10.0-rc.2

package/lib/browser/index.js

@@ -0,0 +1,450 @@
+import { channelsMapper as m } from "./components/async-api/channelsMapper.js";
+import "./components/async-api/generate.js";
+import { messageMapper as a } from "./components/async-api/messageMapper.js";
+import { payloadMapper as n } from "./components/async-api/payloadMapper.js";
+import { responsePayloadMapper as i } from "./components/async-api/responseMapper.js";
+import { anyMapper as l } from "./components/default/anyMapper.js";
+import { classMapper as u } from "./components/default/classMapper.js";
+import { discriminatorMappingMapper as S } from "./components/default/discriminatorMappingMapper.js";
+import { enumsMapper as d } from "./components/default/enumsMapper.js";
+import { genericsMapper as y } from "./components/default/genericsMapper.js";
+import { inheritedClassMapper as g } from "./components/default/inheritedClassMapper.js";
+import { itemMapper as J } from "./components/default/itemMapper.js";
+import { lazyRefMapper as I } from "./components/default/lazyRefMapper.js";
+import { mapMapper as A } from "./components/default/mapMapper.js";
+import { nullableMapper as b } from "./components/default/nullableMapper.js";
+import { objectMapper as F } from "./components/default/objectMapper.js";
+import { ofMapper as N } from "./components/default/ofMapper.js";
+import { propertiesMapper as B } from "./components/default/propertiesMapper.js";
+import { requiredMapper as L } from "./components/default/requiredMapper.js";
+import { schemaMapper as w } from "./components/default/schemaMapper.js";
+import "./components/open-spec/discriminatorMappingMapper.js";
+import { wrapEnumsMapper as U } from "./components/open-spec/enumsMapper.js";
+import "./components/open-spec/generate.js";
+import { nullableMapperOpenApi as K } from "./components/open-spec/nullableMapper.js";
+import { operationInFilesMapper as j } from "./components/open-spec/operationInFilesMapper.js";
+import { operationInParameterMapper as k } from "./components/open-spec/operationInParameterMapper.js";
+import { operationInParametersMapper as X } from "./components/open-spec/operationInParametersMapper.js";
+import { operationInQueryMapper as $ } from "./components/open-spec/operationInQueryMapper.js";
+import { operationMapper as or } from "./components/open-spec/operationMapper.js";
+import { operationMediaMapper as tr } from "./components/open-spec/operationMediaMapper.js";
+import { operationRequestBodyMapper as mr } from "./components/open-spec/operationRequestBodyMapper.js";
+import { operationResponseMapper as ar } from "./components/open-spec/operationResponseMapper.js";
+import { pathsMapper as nr } from "./components/open-spec/pathsMapper.js";
+import { HTTP_STATUS_MESSAGES as ir, getStatusConstant as Mr, getStatusMessage as lr } from "./constants/httpStatusMessages.js";
+import { ARRAY_PROPERTIES as ur, BOOLEAN_PROPERTIES as Or, COMMON_PROPERTIES as Sr, MANY_OF_PROPERTIES as Pr, NUMBER_PROPERTIES as dr, OBJECT_PROPERTIES as Rr, STRING_PROPERTIES as yr } from "./constants/jsonSchemaProperties.js";
+import { OPERATION_HTTP_VERBS as gr, OPERATION_WS_VERBS as Tr, OperationVerbs as Jr } from "./constants/OperationVerbs.js";
+import { Children as Ir } from "./decorators/class/children.js";
+import { DiscriminatorValue as Ar } from "./decorators/class/discriminatorValue.js";
+import { CollectionContains as br } from "./decorators/collections/collectionContains.js";
+import { ArrayOf as Fr, CollectionOf as Dr, MapOf as Nr } from "./decorators/collections/collectionOf.js";
+import { MaxItems as Br } from "./decorators/collections/maxItems.js";
+import { MaxProperties as Lr } from "./decorators/collections/maxProperties.js";
+import { MinItems as wr } from "./decorators/collections/minItems.js";
+import { MinProperties as Ur } from "./decorators/collections/minProperties.js";
+import { UniqueItems as Kr } from "./decorators/collections/uniqueItems.js";
+import { AdditionalProperties as jr } from "./decorators/common/additionalProperties.js";
+import { AllOf as kr } from "./decorators/common/allOf.js";
+import { Allow as Xr } from "./decorators/common/allow.js";
+import { Any as $r } from "./decorators/common/any.js";
+import { AnyOf as oo } from "./decorators/common/anyOf.js";
+import { Const as to } from "./decorators/common/const.js";
+import { CustomKey as mo, CustomKeys as fo } from "./decorators/common/customKey.js";
+import { Default as xo } from "./decorators/common/default.js";
+import { DefaultMsg as so } from "./decorators/common/defaultMsg.js";
+import { Description as Mo } from "./decorators/common/description.js";
+import { DiscriminatorKey as co } from "./decorators/common/discriminatorKey.js";
+import { Enum as Oo } from "./decorators/common/enum.js";
+import { ErrorMsg as Po } from "./decorators/common/errorMsg.js";
+import { Example as yo } from "./decorators/common/example.js";
+import { Examples as go } from "./decorators/common/examples.js";
+import { ExclusiveMaximum as Jo } from "./decorators/common/exclusiveMaximum.js";
+import { ExclusiveMinimum as Io } from "./decorators/common/exclusiveMinimum.js";
+import { DateFormat as Ao, DateTime as _o, Email as bo, Format as Go, TimeFormat as Fo, Uri as Do, Url as No } from "./decorators/common/format.js";
+import { ForwardGroups as Bo } from "./decorators/common/forwardGroups.js";
+import { Groups as Lo } from "./decorators/common/groups.js";
+import { Hidden as wo } from "./decorators/common/hidden.js";
+import { Ignore as Uo } from "./decorators/common/ignore.js";
+import { Integer as Ko } from "./decorators/common/integer.js";
+import { JsonEntityFn as jo } from "./decorators/common/jsonEntityFn.js";
+import { LabelledAs as ko } from "./decorators/common/labelledAs.js";
+import { Max as Xo, Maximum as Zo } from "./decorators/common/maximum.js";
+import { MaxLength as re } from "./decorators/common/maxLength.js";
+import { Min as ee, Minimum as te } from "./decorators/common/minimum.js";
+import { MinLength as me } from "./decorators/common/minLength.js";
+import { MultipleOf as ae } from "./decorators/common/multipleOf.js";
+import { Name as ne } from "./decorators/common/name.js";
+import { Nullable as ie } from "./decorators/common/nullable.js";
+import { OneOf as le } from "./decorators/common/oneOf.js";
+import { Optional as ue } from "./decorators/common/optional.js";
+import { Pattern as Se } from "./decorators/common/pattern.js";
+import { Property as de } from "./decorators/common/property.js";
+import { ReadOnly as ye } from "./decorators/common/readOnly.js";
+import { RecordOf as ge } from "./decorators/common/recordOf.js";
+import { Required as Je } from "./decorators/common/required.js";
+import { RequiredGroups as Ie } from "./decorators/common/requiredGroups.js";
+import { For as Ae, Schema as _e } from "./decorators/common/schema.js";
+import { Title as Ge } from "./decorators/common/title.js";
+import { TypeError as De } from "./decorators/common/typeError.js";
+import { WriteOnly as qe } from "./decorators/common/writeOnly.js";
+import { JsonEntityComponent as He } from "./decorators/config/jsonEntityComponent.js";
+import { GenericOf as Ve } from "./decorators/generics/genericOf.js";
+import { Generics as ze } from "./decorators/generics/generics.js";
+import { AcceptMime as ve } from "./decorators/operations/acceptMime.js";
+import { Consumes as Ye } from "./decorators/operations/consumes.js";
+import { ContentType as We } from "./decorators/operations/contentType.js";
+import { Deprecated as Qe } from "./decorators/operations/deprecated.js";
+import { Header as Ze } from "./decorators/operations/header.js";
+import { In as rt } from "./decorators/operations/in.js";
+import { InFile as et } from "./decorators/operations/inFile.js";
+import { Location as pt } from "./decorators/operations/location.js";
+import { Operation as ft } from "./decorators/operations/operation.js";
+import { OperationId as xt } from "./decorators/operations/operationId.js";
+import { OperationPath as st } from "./decorators/operations/operationPath.js";
+import { Partial as Mt } from "./decorators/operations/partial.js";
+import { Path as ct } from "./decorators/operations/path.js";
+import { Produces as Ot } from "./decorators/operations/produces.js";
+import { Publish as Pt } from "./decorators/operations/publish.js";
+import { Redirect as Rt } from "./decorators/operations/redirect.js";
+import { Returns as Et } from "./decorators/operations/returns.js";
+import { All as Tt, Delete as Jt, Get as ht, Head as It, Options as Ct, Patch as At, Post as _t, Put as bt } from "./decorators/operations/route.js";
+import { Security as Ft } from "./decorators/operations/security.js";
+import { Status as Nt } from "./decorators/operations/status.js";
+import { Subscribe as Bt } from "./decorators/operations/subscribe.js";
+import { Summary as Lt } from "./decorators/operations/summary.js";
+import { Tags as wt } from "./decorators/operations/tags.js";
+import { View as Ut } from "./decorators/operations/view.js";
+import { DecoratorContext as Kt } from "./domain/DecoratorContext.js";
+import { mapAliasedProperties as jt } from "./domain/JsonAliasMap.js";
+import { JsonClassStore as kt } from "./domain/JsonClassStore.js";
+import { Discriminator as Xt } from "./domain/JsonDiscriminator.js";
+import { JsonEntitiesContainer as $t, JsonEntityStore as rp } from "./domain/JsonEntityStore.js";
+import { JsonFormatTypes as ep } from "./domain/JsonFormatTypes.js";
+import { JsonLazyRef as pp } from "./domain/JsonLazyRef.js";
+import { JsonMap as fp } from "./domain/JsonMap.js";
+import { JsonMedia as xp } from "./domain/JsonMedia.js";
+import { EndpointMetadata as sp, JsonMethodStore as ip } from "./domain/JsonMethodStore.js";
+import { JsonMethodPath as lp, JsonOperation as cp } from "./domain/JsonOperation.js";
+import { JsonOperationPathsMap as Op } from "./domain/JsonOperationPathsMap.js";
+import { JsonOperationRoute as Pp } from "./domain/JsonOperationRoute.js";
+import { JsonParameter as Rp } from "./domain/JsonParameter.js";
+import { JsonParameterStore as Ep, ParamMetadata as gp } from "./domain/JsonParameterStore.js";
+import { JsonParameterTypes as Jp, formatParameterType as hp, isParameterType as Ip } from "./domain/JsonParameterTypes.js";
+import { JsonPropertyStore as Ap, PropertyMetadata as _p } from "./domain/JsonPropertyStore.js";
+import { JsonRequestBody as Gp } from "./domain/JsonRequestBody.js";
+import { JsonResponse as Dp } from "./domain/JsonResponse.js";
+import { JsonSchema as qp } from "./domain/JsonSchema.js";
+import { SpecTypes as Hp } from "./domain/SpecTypes.js";
+import { allOf as Vp } from "./fn/allOf.js";
+import { any as zp } from "./fn/any.js";
+import { anyOf as vp } from "./fn/anyOf.js";
+import { boolean as Yp } from "./fn/boolean.js";
+import { array as Wp, map as kp, set as Qp } from "./fn/collection.js";
+import { date as Zp, datetime as $p, time as rm } from "./fn/date.js";
+import { email as em } from "./fn/email.js";
+import { enums as pm } from "./fn/enums.js";
+import { from as fm } from "./fn/from.js";
+import { integer as xm } from "./fn/integer.js";
+import { lazyRef as sm } from "./fn/lazyRef.js";
+import { number as Mm } from "./fn/number.js";
+import { object as cm } from "./fn/object.js";
+import { oneOf as Om } from "./fn/oneOf.js";
+import { string as Pm } from "./fn/string.js";
+import { uri as Rm } from "./fn/uri.js";
+import { url as Em } from "./fn/url.js";
+import { alterIgnore as Tm } from "./hooks/alterIgnore.js";
+import { alterOneOf as hm } from "./hooks/alterOneOf.js";
+import { alterRequiredGroups as Cm } from "./hooks/alterRequiredGroups.js";
+import { enumsRegistry as _m } from "./registries/enumRegistries.js";
+import { execMapper as Gm, execOneOfMapper as Fm, getJsonSchemaMapper as Dm, hasMapper as Nm, registerJsonSchemaMapper as qm } from "./registries/JsonSchemaMapperContainer.js";
+import { buildPath as Hm } from "./utils/buildPath.js";
+import { concatParameters as Vm } from "./utils/concatParameters.js";
+import { concatPath as zm } from "./utils/concatPath.js";
+import { defineStatusModel as vm, getStatusModel as Km } from "./utils/defineStatusModel.js";
+import { generateSpec as jm } from "./utils/generateSpec.js";
+import { getGenericsMap as km, mapGenericsOptions as Qm, popGenerics as Xm } from "./utils/generics.js";
+import { getComputedType as $m } from "./utils/getComputedType.js";
+import { getInheritedStores as of } from "./utils/getInheritedStores.js";
+import { getJsonEntityStore as tf } from "./utils/getJsonEntityStore.js";
+import { getJsonPathParameters as mf } from "./utils/getJsonPathParameters.js";
+import { getJsonSchema as af } from "./utils/getJsonSchema.js";
+import { JSON_TYPES as nf, getJsonType as sf } from "./utils/getJsonType.js";
+import { getOperationsRoutes as lf } from "./utils/getOperationsRoutes.js";
+import { getOperationsStores as uf } from "./utils/getOperationsStores.js";
+import { getProperties as Sf, getPropertiesStores as Pf } from "./utils/getPropertiesStores.js";
+import { getSpec as Rf } from "./utils/getSpec.js";
+import { getSpecType as Ef, getSpecTypeFromSpec as gf } from "./utils/getSpecType.js";
+import { isRedirectionStatus as Jf, isSuccessStatus as hf } from "./utils/isSuccessStatus.js";
+import { mapHeaders as Cf } from "./utils/mapHeaders.js";
+import { mapOpenSpec as _f } from "./utils/mapOpenSpec.js";
+import { mapOpenSpec2 as Gf } from "./utils/mapOpenSpec2.js";
+import { mapOpenSpec3 as Df } from "./utils/mapOpenSpec3.js";
+import { mapOpenSpecInfo as qf } from "./utils/mapOpenSpecInfo.js";
+import { mapOperationOptions as Hf } from "./utils/mapOperationOptions.js";
+import { matchGroups as Vf } from "./utils/matchGroups.js";
+import { mergeSpec as zf, parameters as Uf, schemesReducer as vf, security as Kf, tagsReducer as Yf } from "./utils/mergeSpec.js";
+import { getOperationId as Wf, operationIdFormatter as kf } from "./utils/operationIdFormatter.js";
+import { createRef as Xf, createRefName as Zf, toRef as $f } from "./utils/ref.js";
+import { removeHiddenOperation as oa } from "./utils/removeHiddenOperation.js";
+import { serializeEnum as ta, serializeEnumValues as pa } from "./utils/serializeEnumValues.js";
+import { makeOf as fa } from "./utils/somethingOf.js";
+import { toJsonMapCollection as xa } from "./utils/toJsonMapCollection.js";
+import { toJsonRegex as sa } from "./utils/toJsonRegex.js";
+import { Converter as Ma, transformInformation as la, transformSecurity as ca, transformToOS2 as ua } from "./utils/transformToOS2.js";
+import { withErrorMsg as Sa } from "./utils/withErrorMsg.js";
+export {
+  ur as ARRAY_PROPERTIES,
+  ve as AcceptMime,
+  jr as AdditionalProperties,
+  Tt as All,
+  kr as AllOf,
+  Xr as Allow,
+  $r as Any,
+  oo as AnyOf,
+  Fr as ArrayOf,
+  Or as BOOLEAN_PROPERTIES,
+  Sr as COMMON_PROPERTIES,
+  Ir as Children,
+  br as CollectionContains,
+  Dr as CollectionOf,
+  to as Const,
+  Ye as Consumes,
+  We as ContentType,
+  Ma as Converter,
+  mo as CustomKey,
+  fo as CustomKeys,
+  Ao as DateFormat,
+  _o as DateTime,
+  Kt as DecoratorContext,
+  xo as Default,
+  so as DefaultMsg,
+  Jt as Delete,
+  Qe as Deprecated,
+  Mo as Description,
+  Xt as Discriminator,
+  co as DiscriminatorKey,
+  Ar as DiscriminatorValue,
+  bo as Email,
+  sp as EndpointMetadata,
+  Oo as Enum,
+  Po as ErrorMsg,
+  yo as Example,
+  go as Examples,
+  Jo as ExclusiveMaximum,
+  Io as ExclusiveMinimum,
+  Ae as For,
+  Go as Format,
+  Bo as ForwardGroups,
+  Ve as GenericOf,
+  ze as Generics,
+  ht as Get,
+  Lo as Groups,
+  ir as HTTP_STATUS_MESSAGES,
+  It as Head,
+  Ze as Header,
+  wo as Hidden,
+  Uo as Ignore,
+  rt as In,
+  et as InFile,
+  Ko as Integer,
+  nf as JSON_TYPES,
+  kt as JsonClassStore,
+  $t as JsonEntitiesContainer,
+  He as JsonEntityComponent,
+  jo as JsonEntityFn,
+  rp as JsonEntityStore,
+  ep as JsonFormatTypes,
+  pp as JsonLazyRef,
+  fp as JsonMap,
+  xp as JsonMedia,
+  lp as JsonMethodPath,
+  ip as JsonMethodStore,
+  cp as JsonOperation,
+  Op as JsonOperationPathsMap,
+  Pp as JsonOperationRoute,
+  Rp as JsonParameter,
+  Ep as JsonParameterStore,
+  Jp as JsonParameterTypes,
+  Ap as JsonPropertyStore,
+  Gp as JsonRequestBody,
+  Dp as JsonResponse,
+  qp as JsonSchema,
+  ko as LabelledAs,
+  pt as Location,
+  Pr as MANY_OF_PROPERTIES,
+  Nr as MapOf,
+  Xo as Max,
+  Br as MaxItems,
+  re as MaxLength,
+  Lr as MaxProperties,
+  Zo as Maximum,
+  ee as Min,
+  wr as MinItems,
+  me as MinLength,
+  Ur as MinProperties,
+  te as Minimum,
+  ae as MultipleOf,
+  dr as NUMBER_PROPERTIES,
+  ne as Name,
+  ie as Nullable,
+  Rr as OBJECT_PROPERTIES,
+  gr as OPERATION_HTTP_VERBS,
+  Tr as OPERATION_WS_VERBS,
+  le as OneOf,
+  ft as Operation,
+  xt as OperationId,
+  st as OperationPath,
+  Jr as OperationVerbs,
+  ue as Optional,
+  Ct as Options,
+  gp as ParamMetadata,
+  Mt as Partial,
+  At as Patch,
+  ct as Path,
+  Se as Pattern,
+  _t as Post,
+  Ot as Produces,
+  de as Property,
+  _p as PropertyMetadata,
+  Pt as Publish,
+  bt as Put,
+  ye as ReadOnly,
+  ge as RecordOf,
+  Rt as Redirect,
+  Je as Required,
+  Ie as RequiredGroups,
+  Et as Returns,
+  yr as STRING_PROPERTIES,
+  _e as Schema,
+  Ft as Security,
+  Hp as SpecTypes,
+  Nt as Status,
+  Bt as Subscribe,
+  Lt as Summary,
+  wt as Tags,
+  Fo as TimeFormat,
+  Ge as Title,
+  De as TypeError,
+  Kr as UniqueItems,
+  Do as Uri,
+  No as Url,
+  Ut as View,
+  qe as WriteOnly,
+  Vp as allOf,
+  Tm as alterIgnore,
+  hm as alterOneOf,
+  Cm as alterRequiredGroups,
+  zp as any,
+  l as anyMapper,
+  vp as anyOf,
+  Wp as array,
+  Yp as boolean,
+  Hm as buildPath,
+  m as channelsMapper,
+  u as classMapper,
+  Vm as concatParameters,
+  zm as concatPath,
+  Xf as createRef,
+  Zf as createRefName,
+  Zp as date,
+  $p as datetime,
+  vm as defineStatusModel,
+  S as discriminatorMappingMapper,
+  em as email,
+  pm as enums,
+  d as enumsMapper,
+  _m as enumsRegistry,
+  Gm as execMapper,
+  Fm as execOneOfMapper,
+  hp as formatParameterType,
+  fm as from,
+  jm as generateSpec,
+  y as genericsMapper,
+  $m as getComputedType,
+  km as getGenericsMap,
+  of as getInheritedStores,
+  tf as getJsonEntityStore,
+  mf as getJsonPathParameters,
+  af as getJsonSchema,
+  Dm as getJsonSchemaMapper,
+  sf as getJsonType,
+  Wf as getOperationId,
+  lf as getOperationsRoutes,
+  uf as getOperationsStores,
+  Sf as getProperties,
+  Pf as getPropertiesStores,
+  Rf as getSpec,
+  Ef as getSpecType,
+  gf as getSpecTypeFromSpec,
+  Mr as getStatusConstant,
+  lr as getStatusMessage,
+  Km as getStatusModel,
+  Nm as hasMapper,
+  g as inheritedClassMapper,
+  xm as integer,
+  Ip as isParameterType,
+  Jf as isRedirectionStatus,
+  hf as isSuccessStatus,
+  J as itemMapper,
+  sm as lazyRef,
+  I as lazyRefMapper,
+  fa as makeOf,
+  kp as map,
+  jt as mapAliasedProperties,
+  Qm as mapGenericsOptions,
+  Cf as mapHeaders,
+  A as mapMapper,
+  _f as mapOpenSpec,
+  Gf as mapOpenSpec2,
+  Df as mapOpenSpec3,
+  qf as mapOpenSpecInfo,
+  Hf as mapOperationOptions,
+  Vf as matchGroups,
+  zf as mergeSpec,
+  a as messageMapper,
+  b as nullableMapper,
+  K as nullableMapperOpenApi,
+  Mm as number,
+  cm as object,
+  F as objectMapper,
+  N as ofMapper,
+  Om as oneOf,
+  kf as operationIdFormatter,
+  j as operationInFilesMapper,
+  k as operationInParameterMapper,
+  X as operationInParametersMapper,
+  $ as operationInQueryMapper,
+  or as operationMapper,
+  tr as operationMediaMapper,
+  mr as operationRequestBodyMapper,
+  ar as operationResponseMapper,
+  Uf as parameters,
+  nr as pathsMapper,
+  n as payloadMapper,
+  Xm as popGenerics,
+  B as propertiesMapper,
+  qm as registerJsonSchemaMapper,
+  oa as removeHiddenOperation,
+  L as requiredMapper,
+  i as responsePayloadMapper,
+  w as schemaMapper,
+  vf as schemesReducer,
+  Kf as security,
+  ta as serializeEnum,
+  pa as serializeEnumValues,
+  Qp as set,
+  Pm as string,
+  Yf as tagsReducer,
+  rm as time,
+  xa as toJsonMapCollection,
+  sa as toJsonRegex,
+  $f as toRef,
+  la as transformInformation,
+  ca as transformSecurity,
+  ua as transformToOS2,
+  Rm as uri,
+  Em as url,
+  Sa as withErrorMsg,
+  U as wrapEnumsMapper
+};
+//# sourceMappingURL=index.js.map

package/lib/browser/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/browser/registries/JsonSchemaMapperContainer.js

@@ -0,0 +1,27 @@
+const a = /* @__PURE__ */ new Map();
+function f(e, n, r) {
+  return a.set(r ? `${r}:${e}` : e, n);
+}
+function u(e, n) {
+  const r = a.get(`${n == null ? void 0 : n.specType}:${e}`) || a.get(e);
+  if (r)
+    return r;
+  throw new Error(`JsonSchema ${e} mapper doesn't exists`);
+}
+function h(e, n, r, c) {
+  return u(e, r)(...n, r, c);
+}
+function t(e) {
+  return a.has(e);
+}
+function p(e, n) {
+  return e.find((r) => a.has(`${n == null ? void 0 : n.specType}:${r}`)) || e.find((r) => a.has(r));
+}
+export {
+  h as execMapper,
+  p as execOneOfMapper,
+  u as getJsonSchemaMapper,
+  t as hasMapper,
+  f as registerJsonSchemaMapper
+};
+//# sourceMappingURL=JsonSchemaMapperContainer.js.map

package/lib/browser/registries/JsonSchemaMapperContainer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonSchemaMapperContainer.js","sources":["../../../src/registries/JsonSchemaMapperContainer.ts"],"sourcesContent":["import {SpecTypes} from \"../domain/SpecTypes.js\";\n\n/**\n * @ignore\n */\nexport interface JsonSchemaMapper {\n  (...args: any[]): any;\n}\n\n/**\n * @ignore\n */\nconst JsonSchemaMappersContainer: Map<string, JsonSchemaMapper> = new Map();\n\n/**\n * @ignore\n */\nexport function registerJsonSchemaMapper(type: string, mapper: JsonSchemaMapper, spec?: SpecTypes) {\n  return JsonSchemaMappersContainer.set(spec ? `${spec}:${type}` : type, mapper);\n}\n\n/**\n * @ignore\n */\nexport function getJsonSchemaMapper(type: string, options: any): JsonSchemaMapper {\n  const mapper = JsonSchemaMappersContainer.get(`${options?.specType}:${type}`)! || JsonSchemaMappersContainer.get(type)!;\n\n  if (mapper) {\n    return mapper;\n  }\n\n  // istanbul ignore next\n  throw new Error(`JsonSchema ${type} mapper doesn't exists`);\n}\n\n/**\n * @ignore\n */\nexport function execMapper(type: string, args: any[], options: any, parent?: any): any {\n  return getJsonSchemaMapper(type, options)(...args, options, parent);\n}\n\nexport function hasMapper(type: string) {\n  return JsonSchemaMappersContainer.has(type);\n}\n\nexport function execOneOfMapper(types: string[], options: any): string {\n  return (\n    types.find((type) => JsonSchemaMappersContainer.has(`${options?.specType}:${type}`)) ||\n    types.find((type) => JsonSchemaMappersContainer.has(type))!\n  );\n}\n"],"names":["JsonSchemaMappersContainer","registerJsonSchemaMapper","type","mapper","spec","getJsonSchemaMapper","options","execMapper","args","parent","hasMapper","execOneOfMapper","types"],"mappings":"AAYA,MAAMA,wBAAgE,IAAI;AAK1D,SAAAC,EAAyBC,GAAcC,GAA0BC,GAAkB;AAC1F,SAAAJ,EAA2B,IAAII,IAAO,GAAGA,CAAI,IAAIF,CAAI,KAAKA,GAAMC,CAAM;AAC/E;AAKgB,SAAAE,EAAoBH,GAAcI,GAAgC;AAChF,QAAMH,IAASH,EAA2B,IAAI,GAAGM,KAAA,gBAAAA,EAAS,QAAQ,IAAIJ,CAAI,EAAE,KAAMF,EAA2B,IAAIE,CAAI;AAErH,MAAIC;AACK,WAAAA;AAIT,QAAM,IAAI,MAAM,cAAcD,CAAI,wBAAwB;AAC5D;AAKO,SAASK,EAAWL,GAAcM,GAAaF,GAAcG,GAAmB;AACrF,SAAOJ,EAAoBH,GAAMI,CAAO,EAAE,GAAGE,GAAMF,GAASG,CAAM;AACpE;AAEO,SAASC,EAAUR,GAAc;AAC/B,SAAAF,EAA2B,IAAIE,CAAI;AAC5C;AAEgB,SAAAS,EAAgBC,GAAiBN,GAAsB;AAEnE,SAAAM,EAAM,KAAK,CAACV,MAASF,EAA2B,IAAI,GAAGM,KAAA,gBAAAA,EAAS,QAAQ,IAAIJ,CAAI,EAAE,CAAC,KACnFU,EAAM,KAAK,CAACV,MAASF,EAA2B,IAAIE,CAAI,CAAC;AAE7D;"}

package/lib/browser/registries/enumRegistries.js

@@ -0,0 +1,5 @@
+const e = /* @__PURE__ */ new Map();
+export {
+  e as enumsRegistry
+};
+//# sourceMappingURL=enumRegistries.js.map

package/lib/browser/registries/enumRegistries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enumRegistries.js","sources":["../../../src/registries/enumRegistries.ts"],"sourcesContent":["import {JsonSchema} from \"../domain/JsonSchema.js\";\n\nexport const enumsRegistry = new Map<any, JsonSchema>();\n"],"names":["enumsRegistry"],"mappings":"AAEa,MAAAA,wBAAoB,IAAqB;"}

package/lib/browser/utils/buildPath.js

@@ -0,0 +1,7 @@
+function i(t) {
+  return t.split("/").filter(Boolean).join("/");
+}
+export {
+  i as buildPath
+};
+//# sourceMappingURL=buildPath.js.map

package/lib/browser/utils/buildPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildPath.js","sources":["../../../src/utils/buildPath.ts"],"sourcesContent":["/**\n * Return a sanitized path\n * @param path\n * @ignore\n */\nexport function buildPath(path: string) {\n  return path.split(\"/\").filter(Boolean).join(\"/\");\n}\n"],"names":["buildPath","path"],"mappings":"AAKO,SAASA,EAAUC,GAAc;AAC/B,SAAAA,EAAK,MAAM,GAAG,EAAE,OAAO,OAAO,EAAE,KAAK,GAAG;AACjD;"}

package/lib/browser/utils/concatParameters.js

@@ -0,0 +1,7 @@
+function c(r, e) {
+  return r.map((n) => e.parameters.find((t) => t.in === n.in && t.name === n.name) || n).concat(...e.parameters.filter((n) => n.in !== "path"));
+}
+export {
+  c as concatParameters
+};
+//# sourceMappingURL=concatParameters.js.map

package/lib/browser/utils/concatParameters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"concatParameters.js","sources":["../../../src/utils/concatParameters.ts"],"sourcesContent":["/**\n * @ignore\n */\nexport function concatParameters(parameters: any[], operation: any) {\n  return parameters\n    .map((param) => {\n      const f = operation.parameters.find((p: any) => p.in === param.in && p.name === param.name);\n\n      return f || param;\n    })\n    .concat(...operation.parameters.filter((param: any) => param.in !== \"path\"));\n}\n"],"names":["concatParameters","parameters","operation","param","p"],"mappings":"AAGgB,SAAAA,EAAiBC,GAAmBC,GAAgB;AAC3D,SAAAD,EACJ,IAAI,CAACE,MACMD,EAAU,WAAW,KAAK,CAACE,MAAWA,EAAE,OAAOD,EAAM,MAAMC,EAAE,SAASD,EAAM,IAAI,KAE9EA,CACb,EACA,OAAO,GAAGD,EAAU,WAAW,OAAO,CAACC,MAAeA,EAAM,OAAO,MAAM,CAAC;AAC/E;"}

package/lib/browser/utils/concatPath.js

@@ -0,0 +1,17 @@
+function o(e, n) {
+  if (e instanceof RegExp || n instanceof RegExp) {
+    if (!e)
+      return n;
+    if (!n)
+      return e;
+    const r = e instanceof RegExp ? e : new RegExp(e, "gi"), c = n instanceof RegExp ? n : new RegExp(n, "gi");
+    return new RegExp(r.source + c.source, (r.global ? "g" : "") + (r.ignoreCase ? "i" : "") + (r.multiline ? "m" : ""));
+  }
+  e && n && e.endsWith("/") && n.startsWith("/") && (n = n.slice(1));
+  const i = (e || "") + (n || "");
+  return i.endsWith("/") && i.length > 1 ? i.slice(0, -1) : i;
+}
+export {
+  o as concatPath
+};
+//# sourceMappingURL=concatPath.js.map

package/lib/browser/utils/concatPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"concatPath.js","sources":["../../../src/utils/concatPath.ts"],"sourcesContent":["export function concatPath(basePath: string | undefined | RegExp, path: string | undefined | RegExp): any {\n  if (basePath instanceof RegExp || path instanceof RegExp) {\n    if (!basePath) {\n      return path;\n    }\n\n    if (!path) {\n      return basePath;\n    }\n\n    const r1 = basePath instanceof RegExp ? basePath : new RegExp(basePath, \"gi\");\n    const r2 = path instanceof RegExp ? path : new RegExp(path, \"gi\");\n\n    return new RegExp(r1.source + r2.source, (r1.global ? \"g\" : \"\") + (r1.ignoreCase ? \"i\" : \"\") + (r1.multiline ? \"m\" : \"\"));\n  }\n\n  if (basePath && path && basePath.endsWith(\"/\") && path.startsWith(\"/\")) {\n    path = path.slice(1);\n  }\n\n  const result = (basePath || \"\") + (path || \"\");\n\n  return result.endsWith(\"/\") && result.length > 1 ? result.slice(0, -1) : result;\n}\n"],"names":["concatPath","basePath","path","r1","r2","result"],"mappings":"AAAgB,SAAAA,EAAWC,GAAuCC,GAAwC;AACpG,MAAAD,aAAoB,UAAUC,aAAgB,QAAQ;AACxD,QAAI,CAACD;AACI,aAAAC;AAGT,QAAI,CAACA;AACI,aAAAD;AAGT,UAAME,IAAKF,aAAoB,SAASA,IAAW,IAAI,OAAOA,GAAU,IAAI,GACtEG,IAAKF,aAAgB,SAASA,IAAO,IAAI,OAAOA,GAAM,IAAI;AAEhE,WAAO,IAAI,OAAOC,EAAG,SAASC,EAAG,SAASD,EAAG,SAAS,MAAM,OAAOA,EAAG,aAAa,MAAM,OAAOA,EAAG,YAAY,MAAM,GAAG;AAAA,EAAA;AAGtH,EAAAF,KAAYC,KAAQD,EAAS,SAAS,GAAG,KAAKC,EAAK,WAAW,GAAG,MAC5DA,IAAAA,EAAK,MAAM,CAAC;AAGf,QAAAG,KAAUJ,KAAY,OAAOC,KAAQ;AAEpC,SAAAG,EAAO,SAAS,GAAG,KAAKA,EAAO,SAAS,IAAIA,EAAO,MAAM,GAAG,EAAE,IAAIA;AAC3E;"}

package/lib/browser/utils/defineStatusModel.js

@@ -0,0 +1,12 @@
+const e = /* @__PURE__ */ new Map();
+function o(t, n) {
+  e.set(t, n);
+}
+function s(t) {
+  return e.get(t);
+}
+export {
+  o as defineStatusModel,
+  s as getStatusModel
+};
+//# sourceMappingURL=defineStatusModel.js.map

package/lib/browser/utils/defineStatusModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineStatusModel.js","sources":["../../../src/utils/defineStatusModel.ts"],"sourcesContent":["import {Type} from \"@tsed/core\";\n\nconst statusesModel: Map<number, Type<any>> = new Map();\n\nexport function defineStatusModel(status: number, model: Type<any>) {\n  statusesModel.set(status, model);\n}\n\nexport function getStatusModel(status: number) {\n  return statusesModel.get(status);\n}\n"],"names":["statusesModel","defineStatusModel","status","model","getStatusModel"],"mappings":"AAEA,MAAMA,wBAA4C,IAAI;AAEtC,SAAAC,EAAkBC,GAAgBC,GAAkB;AACpD,EAAAH,EAAA,IAAIE,GAAQC,CAAK;AACjC;AAEO,SAASC,EAAeF,GAAgB;AACtC,SAAAF,EAAc,IAAIE,CAAM;AACjC;"}

package/lib/browser/utils/generateSpec.js

@@ -0,0 +1,24 @@
+import { getValue as a } from "@tsed/core";
+import { SpecTypes as l } from "../domain/SpecTypes.js";
+import { getSpec as u } from "./getSpec.js";
+import { getSpecTypeFromSpec as g } from "./getSpecType.js";
+import { mapOpenSpec as O } from "./mapOpenSpec.js";
+import { mergeSpec as T } from "./mergeSpec.js";
+import { transformToOS2 as h } from "./transformToOS2.js";
+function v({ tokens: p, ...e }) {
+  const { version: o = "1.0.0", acceptMimes: c, fileSpec: m = {}, specVersion: s } = e, t = O(a(e, "spec", {}), {
+    fileSpec: m,
+    version: o,
+    specVersion: s,
+    acceptMimes: c
+  }), f = g(t);
+  let n = u(p, e);
+  const r = T(t, n);
+  return e.sortPaths && (r.paths = Object.fromEntries(
+    Object.entries(r.paths).sort(([i], [S]) => i.localeCompare(S))
+  )), f === l.SWAGGER ? h(r) : r;
+}
+export {
+  v as generateSpec
+};
+//# sourceMappingURL=generateSpec.js.map

package/lib/browser/utils/generateSpec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateSpec.js","sources":["../../../src/utils/generateSpec.ts"],"sourcesContent":["import {getValue} from \"@tsed/core\";\nimport {OpenSpec2, OpenSpec3} from \"@tsed/openspec\";\n\nimport {SpecTypes} from \"../domain/SpecTypes.js\";\nimport {getSpec, JsonTokenOptions, SpecSerializerOptions} from \"./getSpec.js\";\nimport {getSpecTypeFromSpec} from \"./getSpecType.js\";\nimport {mapOpenSpec} from \"./mapOpenSpec.js\";\nimport {mergeSpec} from \"./mergeSpec.js\";\nimport {transformToOS2} from \"./transformToOS2.js\";\n\nexport interface GenerateSpecOptions extends Omit<SpecSerializerOptions, \"specType\"> {\n  tokens: JsonTokenOptions;\n  version?: string;\n  acceptMimes?: string;\n  specVersion?: string;\n  spec?: any;\n  fileSpec?: any;\n  sortPaths?: boolean;\n}\n\n/**\n * Generate OpenAPI spec from multiple sources (models, files, conf)\n * @param tokens\n * @param options\n */\nexport function generateSpec({tokens, ...options}: GenerateSpecOptions): OpenSpec2 | OpenSpec3 {\n  const {version = \"1.0.0\", acceptMimes, fileSpec = {}, specVersion} = options;\n\n  const defaultSpec = mapOpenSpec(getValue(options, \"spec\", {}), {\n    fileSpec,\n    version,\n    specVersion,\n    acceptMimes\n  });\n\n  const specType = getSpecTypeFromSpec(defaultSpec);\n\n  let controllersSpec: any = getSpec(tokens, options);\n  const spec = mergeSpec(defaultSpec, controllersSpec) as OpenSpec2 | OpenSpec3;\n\n  if (options.sortPaths) {\n    spec.paths = Object.fromEntries(\n      Object.entries(spec.paths!).sort(([k1], [k2]) => {\n        return k1.localeCompare(k2);\n      })\n    );\n  }\n\n  if (specType === SpecTypes.SWAGGER) {\n    return transformToOS2(spec) as any;\n  }\n\n  return spec;\n}\n"],"names":["generateSpec","tokens","options","version","acceptMimes","fileSpec","specVersion","defaultSpec","mapOpenSpec","getValue","specType","getSpecTypeFromSpec","controllersSpec","getSpec","spec","mergeSpec","k1","k2","SpecTypes","transformToOS2"],"mappings":";;;;;;;AAyBO,SAASA,EAAa,EAAC,QAAAC,GAAQ,GAAGC,KAAsD;AACvF,QAAA,EAAC,SAAAC,IAAU,SAAS,aAAAC,GAAa,UAAAC,IAAW,CAAC,GAAG,aAAAC,MAAeJ,GAE/DK,IAAcC,EAAYC,EAASP,GAAS,QAAQ,CAAA,CAAE,GAAG;AAAA,IAC7D,UAAAG;AAAA,IACA,SAAAF;AAAA,IACA,aAAAG;AAAA,IACA,aAAAF;AAAA,EAAA,CACD,GAEKM,IAAWC,EAAoBJ,CAAW;AAE5C,MAAAK,IAAuBC,EAAQZ,GAAQC,CAAO;AAC5C,QAAAY,IAAOC,EAAUR,GAAaK,CAAe;AAU/C,SARAV,EAAQ,cACVY,EAAK,QAAQ,OAAO;AAAA,IAClB,OAAO,QAAQA,EAAK,KAAM,EAAE,KAAK,CAAC,CAACE,CAAE,GAAG,CAACC,CAAE,MAClCD,EAAG,cAAcC,CAAE,CAC3B;AAAA,EACH,IAGEP,MAAaQ,EAAU,UAClBC,EAAeL,CAAI,IAGrBA;AACT;"}

package/lib/browser/utils/generics.js

@@ -0,0 +1,26 @@
+function i(e, n) {
+  return e.reduce((r, c, s) => r.set(c, n[s]), /* @__PURE__ */ new Map());
+}
+function t(e) {
+  if (e.genericLabels && e.genericTypes) {
+    const { genericLabels: n, genericTypes: r, ...c } = e;
+    return {
+      ...c,
+      generics: i(n, r)
+    };
+  }
+  return e;
+}
+function u(e) {
+  const [n, ...r] = e.nestedGenerics;
+  return {
+    genericTypes: n,
+    nestedGenerics: r
+  };
+}
+export {
+  i as getGenericsMap,
+  t as mapGenericsOptions,
+  u as popGenerics
+};
+//# sourceMappingURL=generics.js.map

package/lib/browser/utils/generics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generics.js","sources":["../../../src/utils/generics.ts"],"sourcesContent":["import {Type} from \"@tsed/core\";\n\nimport {JsonSchema} from \"../domain/JsonSchema.js\";\n\nexport type GenericValue = Type<any> | JsonSchema | any;\n\n/**\n * @ignore\n */\nexport type GenericsMap = Map<string, GenericValue>;\n\n/**\n * @ignore\n */\nexport interface GenericTypes {\n  genericTypes: Type<any>[];\n\n  [key: string]: any;\n}\n\n/**\n * @ignore\n */\nexport interface GenericLabels {\n  genericLabels: string[];\n\n  [key: string]: any;\n}\n\n/**\n * @ignore\n */\nexport interface NestedGenerics {\n  nestedGenerics: GenericValue[][];\n\n  [key: string]: any;\n}\n\n/**\n * @ignore\n */\nexport interface GenericsContext extends GenericTypes, GenericLabels, NestedGenerics {\n  generics: GenericsMap;\n}\n\n/**\n * @ignore\n * @param genericLabels\n * @param genericTypes\n */\nexport function getGenericsMap(genericLabels: string[], genericTypes: GenericValue[]): GenericsMap {\n  return genericLabels.reduce((map: Map<string, any>, item: string, index: number) => map.set(item, genericTypes[index]), new Map());\n}\n\n/**\n * @ignore\n * @param options\n */\nexport function mapGenericsOptions(options: Partial<GenericTypes & GenericLabels>) {\n  if (options.genericLabels && options.genericTypes) {\n    const {genericLabels, genericTypes, ...ops} = options;\n\n    return {\n      ...ops,\n      generics: getGenericsMap(genericLabels, genericTypes)\n    };\n  }\n\n  return options;\n}\n\n/**\n * @ignore\n * @param value\n */\nexport function popGenerics(value: NestedGenerics): NestedGenerics & GenericTypes {\n  const [genericTypes, ...out] = value.nestedGenerics;\n\n  return {\n    genericTypes,\n    nestedGenerics: out\n  };\n}\n"],"names":["getGenericsMap","genericLabels","genericTypes","map","item","index","mapGenericsOptions","options","ops","popGenerics","value","out"],"mappings":"AAkDgB,SAAAA,EAAeC,GAAyBC,GAA2C;AACjG,SAAOD,EAAc,OAAO,CAACE,GAAuBC,GAAcC,MAAkBF,EAAI,IAAIC,GAAMF,EAAaG,CAAK,CAAC,GAAG,oBAAI,KAAK;AACnI;AAMO,SAASC,EAAmBC,GAAgD;AAC7E,MAAAA,EAAQ,iBAAiBA,EAAQ,cAAc;AACjD,UAAM,EAAC,eAAAN,GAAe,cAAAC,GAAc,GAAGM,EAAO,IAAAD;AAEvC,WAAA;AAAA,MACL,GAAGC;AAAA,MACH,UAAUR,EAAeC,GAAeC,CAAY;AAAA,IACtD;AAAA,EAAA;AAGK,SAAAK;AACT;AAMO,SAASE,EAAYC,GAAsD;AAChF,QAAM,CAACR,GAAc,GAAGS,CAAG,IAAID,EAAM;AAE9B,SAAA;AAAA,IACL,cAAAR;AAAA,IACA,gBAAgBS;AAAA,EAClB;AACF;"}

package/lib/browser/utils/getComputedType.js

@@ -0,0 +1,8 @@
+import { isPromise as s, isClass as o, isSymbol as n, isPrimitiveOrPrimitiveClass as l, isClassObject as m, isDate as u, isCollection as c, classOf as f, isArrowFn as r } from "@tsed/core";
+function e(i) {
+  return s(i) || i === Function ? Object : o(i) || n(i) || l(i) || m(i) || u(i) || c(i) ? f(i) : r(i) ? i() : i;
+}
+export {
+  e as getComputedType
+};
+//# sourceMappingURL=getComputedType.js.map

package/lib/browser/utils/getComputedType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getComputedType.js","sources":["../../../src/utils/getComputedType.ts"],"sourcesContent":["import {\n  classOf,\n  isArrowFn,\n  isClass,\n  isClassObject,\n  isCollection,\n  isDate,\n  isFunction,\n  isPrimitiveOrPrimitiveClass,\n  isPromise,\n  isSymbol,\n  Type\n} from \"@tsed/core\";\n\n/**\n * @ignore\n */\nexport function getComputedType(target: any): Type<any> {\n  if (isPromise(target) || target === Function) {\n    return Object;\n  }\n\n  if (\n    isClass(target) ||\n    isSymbol(target) ||\n    isPrimitiveOrPrimitiveClass(target) ||\n    isClassObject(target) ||\n    isDate(target) ||\n    isCollection(target)\n  ) {\n    return classOf(target);\n  }\n\n  if (isArrowFn(target)) {\n    return (target as any)();\n  }\n\n  return target;\n}\n"],"names":["getComputedType","target","isPromise","isClass","isSymbol","isPrimitiveOrPrimitiveClass","isClassObject","isDate","isCollection","classOf","isArrowFn"],"mappings":";AAiBO,SAASA,EAAgBC,GAAwB;AACtD,SAAIC,EAAUD,CAAM,KAAKA,MAAW,WAC3B,SAIPE,EAAQF,CAAM,KACdG,EAASH,CAAM,KACfI,EAA4BJ,CAAM,KAClCK,EAAcL,CAAM,KACpBM,EAAON,CAAM,KACbO,EAAaP,CAAM,IAEZQ,EAAQR,CAAM,IAGnBS,EAAUT,CAAM,IACVA,EAAe,IAGlBA;AACT;"}