@voxgig/apidef 6.2.0 → 6.3.0

package/src/guide/heuristic01.ts

@@ -78,6 +78,10 @@ const IS_ENTCMP_PATH_RATE = 0.41
 
 const METHOD_IDOP: Record<string, string> = {
   GET: 'load',
+  // QUERY (RFC 10008) is a safe, idempotent read carrying its filter in the
+  // request body — a "GET with a body". Treat it as a load; ResolveOperation
+  // promotes it to `list` when the response is a collection.
+  QUERY: 'load',
   POST: 'create',
   PUT: 'update',
   DELETE: 'remove',
@@ -88,6 +92,7 @@ const METHOD_IDOP: Record<string, string> = {
 
 const METHOD_CONSIDER_ORDER: Record<string, number> = {
   'GET': 100,
+  'QUERY': 150,
   'POST': 200,
   'PUT': 300,
   'PATCH': 400,
@@ -226,7 +231,8 @@ function MeasurePath(spec: TaskSpec) {
     (pathdef.patch ? 1 : 0) +
     (pathdef.delete ? 1 : 0) +
     (pathdef.head ? 1 : 0) +
-    (pathdef.options ? 1 : 0)
+    (pathdef.options ? 1 : 0) +
+    (pathdef.query ? 1 : 0)
   )
 
 }
@@ -1098,10 +1104,16 @@ function ResolveTransform(spec: TaskSpec) {
   debugpath(pathStr, methodName, 'TRANSFORM-RES', keysof(resprops))
 
   if (resprops) {
-    if (resprops[entdesc.origname]) {
+    // Only unwrap `body.<entity>` when the entity-named response property is
+    // itself a structured value (object/array/ref/composed schema) that could
+    // actually contain the entity. A scalar property that merely shares the
+    // entity's name (e.g. an entity `advice` whose own fields include a
+    // string field `advice`) is a FIELD of the entity, not a wrapper around
+    // it: the response IS the entity, so it must stay `body` (the default).
+    if (isEntityWrapperProp(resprops[entdesc.origname])) {
       transform.res = '`body.' + entdesc.origname + '`'
     }
-    else if (resprops[entdesc.name]) {
+    else if (isEntityWrapperProp(resprops[entdesc.name])) {
       transform.res = '`body.' + entdesc.name + '`'
     }
   }
@@ -1343,6 +1355,30 @@ function getResponseSchema(response: any) {
 }
 
 
+// A response property only "wraps" the entity when it is itself a structured
+// value that could contain the entity: an object, an array, a $ref, or a
+// composed (allOf/oneOf/anyOf) schema. A scalar property (string, integer,
+// number, boolean) that merely shares the entity's name is a field of the
+// entity, not a wrapper, so the response must not be unwrapped down to it.
+function isEntityWrapperProp(propSchema: any): boolean {
+  if (null == propSchema || 'object' !== typeof propSchema) {
+    return false
+  }
+  if (null != propSchema.$ref) {
+    return true
+  }
+  if (null != propSchema.properties ||
+    null != propSchema.items ||
+    null != propSchema.allOf ||
+    null != propSchema.oneOf ||
+    null != propSchema.anyOf) {
+    return true
+  }
+  const t = propSchema.type
+  return 'object' === t || 'array' === t
+}
+
+
 function inferEntityName(
   mdesc: any,
   parts: string[],
@@ -1429,6 +1465,13 @@ function probableEntityMethod(
       prob_why = 'putish'
       probent = true
     }
+
+    // QUERY (RFC 10008) carries a filter body but is a safe read, so — like
+    // GET — it implies an entity, not an action.
+    else if ('QUERY' === mdesc.method) {
+      prob_why = 'query'
+      probent = true
+    }
   }
   else if ('GET' === mdesc.method) {
     prob_why = 'get'

package/src/parse.ts

@@ -75,7 +75,7 @@ async function parseOpenAPI(source: any, _meta?: any) {
   // Validate it's an OpenAPI or Swagger spec
   if (!parsed.openapi && !parsed.swagger) {
     throw new Error(
-      `@voxgig/apidef: parse: Unsupported OpenAPI version: undefined`
+      `@voxgig/apidef: parse: Unsupported spec: missing 'openapi' or 'swagger' version field`
     )
   }
 
@@ -109,6 +109,14 @@ async function parseOpenAPI(source: any, _meta?: any) {
 // Single-pass tree walk that:
 // 1. Preserves original $ref values as x-ref
 // 2. Resolves $ref JSON pointers in-place
+//
+// NOTE: resolution inlines a shallow copy of the target ({ ...resolved }),
+// so multiple references to the same component share that component's
+// nested child objects. Downstream consumers must therefore treat the
+// resolved schema as read-only — mutating an inlined sub-object would leak
+// across every site that referenced the same component. (A deep clone is
+// deliberately avoided: schemas can be self-referential, which would make
+// cloning non-terminating.)
 function addXRefsAndResolve(obj: any, root: any, visited?: WeakSet<any>) {
   if (!obj || typeof obj !== 'object') return
   if (!visited) visited = new WeakSet()

package/src/transform/field.ts

@@ -54,7 +54,7 @@ const fieldTransform: Transform = async function(
               seen[opfield.name] = opfield
             }
             else {
-              mergeField(ment, mop, mpoint, def, seen[opfield.name], opfield)
+              mergeField(mop, seen[opfield.name], opfield)
             }
           }
         }
@@ -152,7 +152,11 @@ function findFieldDefs(
       }
     }
 
-    if (requestBody) {
+    // A QUERY (RFC 10008) request body is a filter/query schema, not the
+    // entity shape, so it must not contribute entity fields. Fields for a
+    // QUERY op come from its response only. Other methods (POST/PUT/PATCH)
+    // carry the entity in the body, so merge as usual.
+    if (requestBody && 'query' !== method) {
       fieldSets = [
         fieldSets,
         getx(requestBody, 'content "application/json" schema') ??
@@ -174,10 +178,17 @@ function findFieldDefs(
       const requiredNames: string[] = Array.isArray(fieldSet?.required)
         ? fieldSet.required : []
       each(fieldSet?.properties, (property: any) => {
-        if (requiredNames.includes(property.key$)) {
-          property.required = true
+        // Don't mutate the parsed schema: a $ref-resolved schema is shared
+        // across every operation that references it, so flipping
+        // `property.required = true` here would leak this operation's
+        // required[] onto all the others. Derive `required` onto a shallow
+        // copy instead (matches the Go port, which builds fresh field defs).
+        if (!property.required && requiredNames.includes(property.key$)) {
+          fielddefs.push({ ...property, required: true })
+        }
+        else {
+          fielddefs.push(property)
         }
-        fielddefs.push(property)
       })
     })
   }
@@ -216,7 +227,7 @@ function findExampleObject(opdef: any): any {
   const responses = opdef.responses
   if (null == responses) return null
 
-  const resdef = responses[200] ?? responses[201] ?? responses['200'] ?? responses['201']
+  const resdef = responses['200'] ?? responses['201']
   if (null == resdef) return null
 
   // OpenAPI 3.x: content.application/json.example
@@ -310,22 +321,18 @@ function inferTypeFromValue(value: any): string {
 
 
 function mergeField(
-  ment: ModelEntity,
   mop: ModelOp,
-  mpoint: ModelPoint,
-  def: any,
-  exisingField: ModelField,
+  existingField: ModelField,
   newField: ModelField
 ) {
-
-  if (newField.req !== exisingField.req) {
-    exisingField.op[mop.name] = {
+  if (newField.req !== existingField.req) {
+    existingField.op[mop.name] = {
       req: newField.req,
       type: newField.type,
     }
   }
 
-  return exisingField
+  return existingField
 }
 
 

package/src/transform/operation.ts

@@ -152,7 +152,13 @@ function resolveOp(opname: OpName, gent: GuideEntity): undefined | ModelOp {
           rename: p.rename,
           method: p.method,
           args: {},
-          transform: opdesc.transform ?? {},
+          // Carry the per-path op transform (res `body.<entity>`, req
+          // `{<entity>: reqdata}`) computed by the guide step
+          // (heuristic01 ResolveTransform) onto the point. It lives on the
+          // path's op, not on the op-map entry, so read p.op.transform.
+          // Spread into a fresh object so the default-fill below never
+          // mutates the shared guide op.transform across points.
+          transform: { ...((p as any).op?.transform ?? {}) },
           select: {
             exist: []
           }

package/src/transform/top.ts

@@ -44,6 +44,18 @@ const topTransform = async function(
   kit.info = stringifyInfoScalars(def.info ?? {})
   kit.info.servers = stringifyInfoScalars(def.servers ?? [])
 
+  // Public APIs that declare NO authentication (no security schemes, no
+  // top-level `security`, and no per-operation `security`) get an explicit
+  // no-auth signal in the model. Downstream sdkgen reads it via
+  // isAuthActive() (main.kit.info.auth === false) to suppress apikey/auth
+  // code, docs and examples. Only the negative signal is emitted: when the
+  // spec DOES declare auth we leave `auth` unset so the SDK's own config
+  // (main.kit.config.auth) governs. Set AFTER stringifyInfoScalars so the
+  // value stays a real boolean rather than the string "false".
+  if (!specDeclaresAuth(def)) {
+    kit.info.auth = false
+  }
+
   // Swagger 2.0
   if (def.host) {
     kit.info.servers.push({
@@ -51,6 +63,28 @@ const topTransform = async function(
     })
   }
 
+  // Some specs omit the scheme on `servers[].url` — e.g. the Art
+  // Institute of Chicago lists `api.artic.edu/api/v1` (no
+  // https://). Go's net/http barfs on that with "unsupported
+  // protocol scheme". Default to https when the URL has no scheme
+  // and the value isn't a relative path.
+  for (const server of (kit.info.servers as any[])) {
+    if (!server || 'string' !== typeof server.url) continue
+    const url: string = server.url.trim()
+    if (url === '') continue
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(url)) continue   // already has scheme
+    // `//host/path` is a protocol-relative URL — meaningless to a
+    // backend SDK, treat as missing-scheme and default to https.
+    if (url.startsWith('//')) {
+      server.url = 'https:' + url
+      continue
+    }
+    // `/path` is path-only (relative to wherever the spec is served).
+    // Leave it untouched; it's a valid OpenAPI form.
+    if (url.startsWith('/')) continue
+    server.url = 'https://' + url
+  }
+
   // A usable SDK requires a base URL. OpenAPI 3 puts it in `servers[].url`;
   // Swagger 2 derives it from `host` + `basePath`. If neither yields a
   // non-empty url, the generated SDK has no way to issue requests, so fail
@@ -66,6 +100,44 @@ const topTransform = async function(
 }
 
 
+// Does the spec declare any authentication? True if it defines security
+// schemes (OpenAPI 3 `components.securitySchemes` or Swagger 2
+// `securityDefinitions`), a top-level `security` requirement, or a
+// per-operation `security` requirement. Used to emit a no-auth signal
+// (info.auth: false) for fully public APIs.
+function specDeclaresAuth(def: any): boolean {
+  if (null == def || 'object' !== typeof def) return false
+
+  const nonEmptyObj = (v: any) =>
+    null != v && 'object' === typeof v && Object.keys(v).length > 0
+
+  // OpenAPI 3 security schemes.
+  if (nonEmptyObj(def.components?.securitySchemes)) return true
+
+  // Swagger 2 security definitions.
+  if (nonEmptyObj(def.securityDefinitions)) return true
+
+  // Top-level security requirement.
+  if (Array.isArray(def.security) && def.security.length > 0) return true
+
+  // Per-operation security requirement.
+  const paths = def.paths
+  if (paths && 'object' === typeof paths) {
+    for (const pathItem of Object.values(paths)) {
+      if (null == pathItem || 'object' !== typeof pathItem) continue
+      for (const op of Object.values(pathItem as Record<string, any>)) {
+        if (op && 'object' === typeof op &&
+          Array.isArray((op as any).security) && (op as any).security.length > 0) {
+          return true
+        }
+      }
+    }
+  }
+
+  return false
+}
+
+
 // OpenAPI's `info` object (and the `servers` array) declares every scalar
 // leaf as a string. YAML/JSON parsers don't enforce that — `version: 2`
 // without quotes parses as the number 2, `version: true` as a boolean.

package/src/types.ts

@@ -63,6 +63,14 @@ const ModelShape = Shape({
       guide: {},
       entity: {},
     },
+    // Per-model overrides. `custom.plurals` is a plural → singular map
+    // consulted by depluralize() before the built-in IRREGULARS table
+    // and rule chain. Use for API-specific terminology where the
+    // generic English rules misclassify a name — e.g. {axes: axe}
+    // for a fitness API where the singular is "axe" not "axis".
+    custom: {
+      plurals: {},
+    },
   }
 })
 const OpenModelShape = Shape(Open(ModelShape), { name: 'Model' })
@@ -179,7 +187,7 @@ import type {
   BasicMethodDesc,
 } from './desc'
 
-type MethodName = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | ''
+type MethodName = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'QUERY' | ''
 
 
 

package/src/utility.ts

@@ -110,103 +110,258 @@ function formatJsonSrc(jsonsrc: string) {
 }
 
 
-// Common irregular plurals - hoisted to module scope to avoid re-allocation per call.
+// Common irregular plurals, in the form plural → singular. Used at the
+// head of depluralize() to short-circuit cases the suffix rules below
+// would otherwise mishandle.
+//
+// Three over-strip classes are worked around here because the surface
+// form gives no clean discriminator:
+//
+//   * `-Vse+s` plurals (houses, phases, noses, …) would hit the
+//     generic `-ses → ∅` rule and become hous/phas/nos. Every such
+//     -se+s plural needs an explicit entry.
+//
+//   * `-che+s` plurals (caches, niches, headaches, …) would hit the
+//     generic `-ches → ∅` rule and become cach/nich/headach. Same
+//     pattern: no letter-doubling tell exists (cache vs church both
+//     have a single 'ch'), so each -che singular is enumerated.
+//
+//   * `-oe+s` plurals (shoes, canoes, oboes) would hit the generic
+//     `-oes → -o` rule (for potatoes/heroes) and become sho/cano/obo.
+//     Only collision-safe entries are listed: a key must not also be a
+//     suffix of a real `-o`+es plural (e.g. `toes` is excluded because
+//     it would turn tomatoes → tomatoe).
+//
+// Keys are lowercase; depluralize() does a case-insensitive lookup
+// and reapplies the caller's casing on the way out.
 const IRREGULARS: Record<string, string> = {
   'analytics': 'analytics',
   'analyses': 'analysis',
   'appendices': 'appendix',
+  'avalanches': 'avalanche',
   'axes': 'axis',
+  'caches': 'cache',
+  'canoes': 'canoe',
+  'cases': 'case',
   'children': 'child',
+  'cliches': 'cliche',
   'courses': 'course',
+  'creches': 'creche',
   'crises': 'crisis',
   'criteria': 'criterion',
   // 'data': 'datum',
   'diagnoses': 'diagnosis',
+  'doses': 'dose',
+  'douches': 'douche',
   'feet': 'foot',
-  'furnace': 'furnaces',
+  'furnaces': 'furnace',
   'geese': 'goose',
+  'headaches': 'headache',
   'horses': 'horse',
-  'house': 'houses',
+  'hoses': 'hose',
+  'houses': 'house',
   'indices': 'index',
   'lens': 'lens',
-  'license': 'licenses',
+  'licenses': 'license',
   'matrices': 'matrix',
   'men': 'man',
   'mice': 'mouse',
+  'moustaches': 'moustache',
   'movies': 'movie',
-  'notice': 'notices',
+  'mustaches': 'mustache',
+  'niches': 'niche',
+  'noses': 'nose',
+  'notices': 'notice',
+  'nurses': 'nurse',
   'oases': 'oasis',
-  'phrase': 'phrase',
+  'oboes': 'oboe',
+  'pastiches': 'pastiche',
+  'pauses': 'pause',
+  'phases': 'phase',
+  'phrases': 'phrase',
+  'practices': 'practice',
+  'premises': 'premise',
+  'promises': 'promise',
+  'psyches': 'psyche',
+  'purses': 'purse',
   'releases': 'release',
+  'roses': 'rose',
   'people': 'person',
   'phenomena': 'phenomenon',
-  'practice': 'practices',
-  'promise': 'promises',
   'series': 'series',
+  'shoes': 'shoe',
+  'sources': 'source',
   'species': 'species',
   'teeth': 'tooth',
   'theses': 'thesis',
+  'verses': 'verse',
   'vertices': 'vertex',
   'women': 'woman',
   'yes': 'yes',
 }
 
+// Sorted longest-first so the most specific IRREGULARS suffix wins.
+// Without this, 'women' would be shadowed by 'men' (3 < 5) under
+// insertion-order iteration. Both happen to round-trip correctly
+// today, but the sort makes any future entry safe by construction.
+const IRREGULAR_KEYS = Object.keys(IRREGULARS).sort((a, b) => b.length - a.length)
+
+
+// Reapply the case pattern of `source` to `target`. Used so the
+// case-insensitive lookups in depluralize() preserve the caller's
+// casing on the way out (HOUSES → HOUSE, Houses → House, houses →
+// house). Falls through to `target` unchanged for mixed-case sources
+// that don't fit one of the three canonical patterns.
+function matchCase(source: string, target: string): string {
+  if (source === source.toLowerCase()) return target.toLowerCase()
+  if (source === source.toUpperCase()) return target.toUpperCase()
+  if (source[0] === source[0].toUpperCase()) {
+    return target[0].toUpperCase() + target.slice(1).toLowerCase()
+  }
+  return target
+}
+
+
+// Per-model plural overrides, populated from the model's
+// `main.custom.plurals` section at apidef pipeline entry and cleared
+// between runs. Checked by depluralize() before the built-in
+// IRREGULARS table and rule chain — so a model can override any
+// default depluralization, including correct-by-default cases, when
+// its domain demands a different singular (e.g. fitness API with
+// {axes: axe}, photography app with {lenses: lens}).
+//
+// Module-level rather than a parameter so the many existing
+// depluralize/canonize call sites across transforms and guide
+// inherit the override without signature churn. apidef is
+// single-model-per-process; if that ever changes, switch this to a
+// per-context map.
+let CUSTOM_PLURALS: Record<string, string> = {}
+let CUSTOM_PLURAL_KEYS: string[] = []
+
+
+function setCustomPlurals(plurals: Record<string, string> | undefined | null) {
+  CUSTOM_PLURALS = {}
+  if (plurals) {
+    for (const k of Object.keys(plurals)) {
+      // Skip null/undefined values so a partially-typed model entry
+      // doesn't poison the map.
+      const v = plurals[k]
+      if (null == v) continue
+      CUSTOM_PLURALS[k.toLowerCase()] = v
+    }
+  }
+  CUSTOM_PLURAL_KEYS = Object.keys(CUSTOM_PLURALS).sort((a, b) => b.length - a.length)
+
+  // canonize() memoizes depluralize() output, and depluralize() consults
+  // CUSTOM_PLURALS — so the cache is only valid for the plural config that
+  // produced it. ApiDef.makeBuild reuses one apidef instance across models,
+  // so without this a second model would read the first model's
+  // custom-plural-affected canonize results. Invalidate on every change.
+  CANONIZE_CACHE.clear()
+}
+
+
+function clearCustomPlurals() {
+  setCustomPlurals(undefined)
+}
+
 function depluralize(word: string): string {
   if (!word || word.length === 0) {
     return word
   }
 
-  if (IRREGULARS[word]) {
-    return IRREGULARS[word]
+  // Case-insensitive throughout: IRREGULARS lookups and every
+  // suffix-rule endsWith() check operate on the lowercased form,
+  // but slice/concat use the original word so the caller's casing
+  // is preserved (HOUSES → HOUSE, Houses → House, houses → house).
+  const lower = word.toLowerCase()
+
+  // Per-model custom plurals win over the built-in IRREGULARS and
+  // rule chain. Same lookup shape: exact match first, then
+  // longest-suffix match against CUSTOM_PLURAL_KEYS.
+  const customExact = CUSTOM_PLURALS[lower]
+  if (customExact) {
+    return matchCase(word, customExact)
+  }
+  for (const ending of CUSTOM_PLURAL_KEYS) {
+    if (lower.endsWith(ending)) {
+      const cut = word.length - ending.length
+      return word.slice(0, cut) + matchCase(word.slice(cut), CUSTOM_PLURALS[ending])
+    }
+  }
+
+  const exact = IRREGULARS[lower]
+  if (exact) {
+    return matchCase(word, exact)
   }
 
-  for (let ending in IRREGULARS) {
-    if (word.endsWith(ending)) {
-      return word.replace(ending, IRREGULARS[ending])
+  for (const ending of IRREGULAR_KEYS) {
+    if (lower.endsWith(ending)) {
+      const cut = word.length - ending.length
+      return word.slice(0, cut) + matchCase(word.slice(cut), IRREGULARS[ending])
     }
   }
 
-  // Rules for regular plurals (applied in order)
+  // Rules for regular plurals (applied in order). The -ies and -ves
+  // rules add a letter, so they need to match the case of the dropped
+  // suffix; all other rules just slice and inherit the caller's case.
 
   // -ies -> -y (cities -> city), but only if result is > 2 chars
-  if (word.endsWith('ies') && word.length > 3) {
-    const result = word.slice(0, -3) + 'y'
+  if (lower.endsWith('ies') && word.length > 3) {
+    const dropped = word.slice(-3)
+    const y = dropped === dropped.toUpperCase() ? 'Y' : 'y'
+    const result = word.slice(0, -3) + y
     if (result.length > 2) {
       return result
     }
   }
 
   // -ves -> -f or -fe (wolves -> wolf, knives -> knife)
-  if (word.endsWith('ves')) {
+  if (lower.endsWith('ves')) {
     const stem = word.slice(0, -3)
+    const dropped = word.slice(-3)
+    const isUpper = dropped === dropped.toUpperCase()
     // Check if it should be -fe (like knife, wife, life)
-    if (['kni', 'wi', 'li'].includes(stem)) {
-      return stem + 'fe'
+    if (['kni', 'wi', 'li'].includes(stem.toLowerCase())) {
+      return stem + (isUpper ? 'FE' : 'fe')
     }
-    return stem + 'f'
+    return stem + (isUpper ? 'F' : 'f')
   }
 
   // -oes -> -o (potatoes -> potato)
-  if (word.endsWith('oes')) {
+  if (lower.endsWith('oes')) {
     return word.slice(0, -2)
   }
 
   // Handle words ending in -nses (like responses, expenses, licenses)
   // These should only lose the final -s, not -es
-  if (word.endsWith('nses')) {
+  if (lower.endsWith('nses')) {
+    return word.slice(0, -1)
+  }
+
+  // -zes plurals come from -ze singulars (prize, size, freeze, maze,
+  // breeze, …) far more often than from a bare -z taking -es. The only
+  // -zes plurals that strip the full -es have a doubled-z stem
+  // (buzz/buzzes, fez/fezzes). Discriminate on -zzes so prizes → prize
+  // instead of priz. Mirrors the -ses/-Vse+s problem the IRREGULARS
+  // table works around for the -se case.
+  if (lower.endsWith('zzes')) {
+    return word.slice(0, -2)
+  }
+  if (lower.endsWith('zes')) {
     return word.slice(0, -1)
   }
 
-  // -ses, -xes, -zes, -shes, -ches -> remove -es (boxes -> box)
-  if (word.endsWith('ses') || word.endsWith('xes') || word.endsWith('zes') ||
-    word.endsWith('shes') || word.endsWith('ches')) {
+  // -ses, -xes, -shes, -ches -> remove -es (boxes -> box)
+  if (lower.endsWith('ses') || lower.endsWith('xes') ||
+    lower.endsWith('shes') || lower.endsWith('ches')) {
     return word.slice(0, -2)
   }
 
   // -s -> remove -s (cats -> cat), but only if result is > 2 chars
-  if (word.endsWith('s') &&
-    !word.endsWith('ss') &&
-    !word.endsWith('us') &&
+  if (lower.endsWith('s') &&
+    !lower.endsWith('ss') &&
+    !lower.endsWith('us') &&
     word.length > 3
   ) {
     return word.slice(0, -1)
@@ -572,7 +727,10 @@ function formatJSONIC(
         '`' + JSON.stringify(v)
           .substring(1)
           .replace(/\\n/g, '\n')
-          .replace(/\\"/g, ':')
+          // Inside a JSONIC backtick literal a double quote is a literal
+          // character, so unescape JSON's \" back to " (was previously
+          // replaced with ':' which silently corrupted quoted text).
+          .replace(/\\"/g, '"')
           .replace(/`/g, '\\`')
           .replace(/"$/, '`'))
       case 'number': return c('number', Number.isFinite(v) ? String(v) : 'null')
@@ -1148,6 +1306,8 @@ export {
   loadFile,
   formatJsonSrc,
   depluralize,
+  setCustomPlurals,
+  clearCustomPlurals,
   find,
   capture,
   pathMatch,

package/README.md

@@ -1,2 +0,0 @@
-# apidef
-API model definition