@nikovirtala/projen-constructs 0.2.1 → 0.2.2

package/node_modules/ajv/lib/2019.ts

@@ -0,0 +1,81 @@
+import type {AnySchemaObject} from "./types"
+import AjvCore, {Options} from "./core"
+
+import draft7Vocabularies from "./vocabularies/draft7"
+import dynamicVocabulary from "./vocabularies/dynamic"
+import nextVocabulary from "./vocabularies/next"
+import unevaluatedVocabulary from "./vocabularies/unevaluated"
+import discriminator from "./vocabularies/discriminator"
+import addMetaSchema2019 from "./refs/json-schema-2019-09"
+
+const META_SCHEMA_ID = "https://json-schema.org/draft/2019-09/schema"
+
+export class Ajv2019 extends AjvCore {
+  constructor(opts: Options = {}) {
+    super({
+      ...opts,
+      dynamicRef: true,
+      next: true,
+      unevaluated: true,
+    })
+  }
+
+  _addVocabularies(): void {
+    super._addVocabularies()
+    this.addVocabulary(dynamicVocabulary)
+    draft7Vocabularies.forEach((v) => this.addVocabulary(v))
+    this.addVocabulary(nextVocabulary)
+    this.addVocabulary(unevaluatedVocabulary)
+    if (this.opts.discriminator) this.addKeyword(discriminator)
+  }
+
+  _addDefaultMetaSchema(): void {
+    super._addDefaultMetaSchema()
+    const {$data, meta} = this.opts
+    if (!meta) return
+    addMetaSchema2019.call(this, $data)
+    this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID
+  }
+
+  defaultMeta(): string | AnySchemaObject | undefined {
+    return (this.opts.defaultMeta =
+      super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : undefined))
+  }
+}
+
+module.exports = exports = Ajv2019
+module.exports.Ajv2019 = Ajv2019
+Object.defineProperty(exports, "__esModule", {value: true})
+
+export default Ajv2019
+
+export {
+  Format,
+  FormatDefinition,
+  AsyncFormatDefinition,
+  KeywordDefinition,
+  KeywordErrorDefinition,
+  CodeKeywordDefinition,
+  MacroKeywordDefinition,
+  FuncKeywordDefinition,
+  Vocabulary,
+  Schema,
+  SchemaObject,
+  AnySchemaObject,
+  AsyncSchema,
+  AnySchema,
+  ValidateFunction,
+  AsyncValidateFunction,
+  ErrorObject,
+  ErrorNoParams,
+} from "./types"
+
+export {Plugin, Options, CodeOptions, InstanceOptions, Logger, ErrorsTextOptions} from "./core"
+export {SchemaCxt, SchemaObjCxt} from "./compile"
+export {KeywordCxt} from "./compile/validate"
+export {DefinedError} from "./vocabularies/errors"
+export {JSONType} from "./compile/rules"
+export {JSONSchemaType} from "./types/json-schema"
+export {_, str, stringify, nil, Name, Code, CodeGen, CodeGenOptions} from "./compile/codegen"
+export {default as ValidationError} from "./runtime/validation_error"
+export {default as MissingRefError} from "./compile/ref_error"

package/node_modules/ajv/lib/2020.ts

@@ -0,0 +1,75 @@
+import type {AnySchemaObject} from "./types"
+import AjvCore, {Options} from "./core"
+
+import draft2020Vocabularies from "./vocabularies/draft2020"
+import discriminator from "./vocabularies/discriminator"
+import addMetaSchema2020 from "./refs/json-schema-2020-12"
+
+const META_SCHEMA_ID = "https://json-schema.org/draft/2020-12/schema"
+
+export class Ajv2020 extends AjvCore {
+  constructor(opts: Options = {}) {
+    super({
+      ...opts,
+      dynamicRef: true,
+      next: true,
+      unevaluated: true,
+    })
+  }
+
+  _addVocabularies(): void {
+    super._addVocabularies()
+    draft2020Vocabularies.forEach((v) => this.addVocabulary(v))
+    if (this.opts.discriminator) this.addKeyword(discriminator)
+  }
+
+  _addDefaultMetaSchema(): void {
+    super._addDefaultMetaSchema()
+    const {$data, meta} = this.opts
+    if (!meta) return
+    addMetaSchema2020.call(this, $data)
+    this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID
+  }
+
+  defaultMeta(): string | AnySchemaObject | undefined {
+    return (this.opts.defaultMeta =
+      super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : undefined))
+  }
+}
+
+module.exports = exports = Ajv2020
+module.exports.Ajv2020 = Ajv2020
+Object.defineProperty(exports, "__esModule", {value: true})
+
+export default Ajv2020
+
+export {
+  Format,
+  FormatDefinition,
+  AsyncFormatDefinition,
+  KeywordDefinition,
+  KeywordErrorDefinition,
+  CodeKeywordDefinition,
+  MacroKeywordDefinition,
+  FuncKeywordDefinition,
+  Vocabulary,
+  Schema,
+  SchemaObject,
+  AnySchemaObject,
+  AsyncSchema,
+  AnySchema,
+  ValidateFunction,
+  AsyncValidateFunction,
+  ErrorObject,
+  ErrorNoParams,
+} from "./types"
+
+export {Plugin, Options, CodeOptions, InstanceOptions, Logger, ErrorsTextOptions} from "./core"
+export {SchemaCxt, SchemaObjCxt} from "./compile"
+export {KeywordCxt} from "./compile/validate"
+export {DefinedError} from "./vocabularies/errors"
+export {JSONType} from "./compile/rules"
+export {JSONSchemaType} from "./types/json-schema"
+export {_, str, stringify, nil, Name, Code, CodeGen, CodeGenOptions} from "./compile/codegen"
+export {default as ValidationError} from "./runtime/validation_error"
+export {default as MissingRefError} from "./compile/ref_error"

package/node_modules/ajv/lib/ajv.ts

@@ -0,0 +1,70 @@
+import type {AnySchemaObject} from "./types"
+import AjvCore from "./core"
+import draft7Vocabularies from "./vocabularies/draft7"
+import discriminator from "./vocabularies/discriminator"
+import * as draft7MetaSchema from "./refs/json-schema-draft-07.json"
+
+const META_SUPPORT_DATA = ["/properties"]
+
+const META_SCHEMA_ID = "http://json-schema.org/draft-07/schema"
+
+export class Ajv extends AjvCore {
+  _addVocabularies(): void {
+    super._addVocabularies()
+    draft7Vocabularies.forEach((v) => this.addVocabulary(v))
+    if (this.opts.discriminator) this.addKeyword(discriminator)
+  }
+
+  _addDefaultMetaSchema(): void {
+    super._addDefaultMetaSchema()
+    if (!this.opts.meta) return
+    const metaSchema = this.opts.$data
+      ? this.$dataMetaSchema(draft7MetaSchema, META_SUPPORT_DATA)
+      : draft7MetaSchema
+    this.addMetaSchema(metaSchema, META_SCHEMA_ID, false)
+    this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID
+  }
+
+  defaultMeta(): string | AnySchemaObject | undefined {
+    return (this.opts.defaultMeta =
+      super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : undefined))
+  }
+}
+
+module.exports = exports = Ajv
+module.exports.Ajv = Ajv
+Object.defineProperty(exports, "__esModule", {value: true})
+
+export default Ajv
+
+export {
+  Format,
+  FormatDefinition,
+  AsyncFormatDefinition,
+  KeywordDefinition,
+  KeywordErrorDefinition,
+  CodeKeywordDefinition,
+  MacroKeywordDefinition,
+  FuncKeywordDefinition,
+  Vocabulary,
+  Schema,
+  SchemaObject,
+  AnySchemaObject,
+  AsyncSchema,
+  AnySchema,
+  ValidateFunction,
+  AsyncValidateFunction,
+  SchemaValidateFunction,
+  ErrorObject,
+  ErrorNoParams,
+} from "./types"
+
+export {Plugin, Options, CodeOptions, InstanceOptions, Logger, ErrorsTextOptions} from "./core"
+export {SchemaCxt, SchemaObjCxt} from "./compile"
+export {KeywordCxt} from "./compile/validate"
+export {DefinedError} from "./vocabularies/errors"
+export {JSONType} from "./compile/rules"
+export {JSONSchemaType} from "./types/json-schema"
+export {_, str, stringify, nil, Name, Code, CodeGen, CodeGenOptions} from "./compile/codegen"
+export {default as ValidationError} from "./runtime/validation_error"
+export {default as MissingRefError} from "./compile/ref_error"

package/node_modules/ajv/lib/compile/codegen/code.ts

@@ -0,0 +1,169 @@
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export abstract class _CodeOrName {
+  abstract readonly str: string
+  abstract readonly names: UsedNames
+  abstract toString(): string
+  abstract emptyStr(): boolean
+}
+
+export const IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i
+
+export class Name extends _CodeOrName {
+  readonly str: string
+  constructor(s: string) {
+    super()
+    if (!IDENTIFIER.test(s)) throw new Error("CodeGen: name must be a valid identifier")
+    this.str = s
+  }
+
+  toString(): string {
+    return this.str
+  }
+
+  emptyStr(): boolean {
+    return false
+  }
+
+  get names(): UsedNames {
+    return {[this.str]: 1}
+  }
+}
+
+export class _Code extends _CodeOrName {
+  readonly _items: readonly CodeItem[]
+  private _str?: string
+  private _names?: UsedNames
+
+  constructor(code: string | readonly CodeItem[]) {
+    super()
+    this._items = typeof code === "string" ? [code] : code
+  }
+
+  toString(): string {
+    return this.str
+  }
+
+  emptyStr(): boolean {
+    if (this._items.length > 1) return false
+    const item = this._items[0]
+    return item === "" || item === '""'
+  }
+
+  get str(): string {
+    return (this._str ??= this._items.reduce((s: string, c: CodeItem) => `${s}${c}`, ""))
+  }
+
+  get names(): UsedNames {
+    return (this._names ??= this._items.reduce((names: UsedNames, c) => {
+      if (c instanceof Name) names[c.str] = (names[c.str] || 0) + 1
+      return names
+    }, {}))
+  }
+}
+
+export type CodeItem = Name | string | number | boolean | null
+
+export type UsedNames = Record<string, number | undefined>
+
+export type Code = _Code | Name
+
+export type SafeExpr = Code | number | boolean | null
+
+export const nil = new _Code("")
+
+type CodeArg = SafeExpr | string | undefined
+
+export function _(strs: TemplateStringsArray, ...args: CodeArg[]): _Code {
+  const code: CodeItem[] = [strs[0]]
+  let i = 0
+  while (i < args.length) {
+    addCodeArg(code, args[i])
+    code.push(strs[++i])
+  }
+  return new _Code(code)
+}
+
+const plus = new _Code("+")
+
+export function str(strs: TemplateStringsArray, ...args: (CodeArg | string[])[]): _Code {
+  const expr: CodeItem[] = [safeStringify(strs[0])]
+  let i = 0
+  while (i < args.length) {
+    expr.push(plus)
+    addCodeArg(expr, args[i])
+    expr.push(plus, safeStringify(strs[++i]))
+  }
+  optimize(expr)
+  return new _Code(expr)
+}
+
+export function addCodeArg(code: CodeItem[], arg: CodeArg | string[]): void {
+  if (arg instanceof _Code) code.push(...arg._items)
+  else if (arg instanceof Name) code.push(arg)
+  else code.push(interpolate(arg))
+}
+
+function optimize(expr: CodeItem[]): void {
+  let i = 1
+  while (i < expr.length - 1) {
+    if (expr[i] === plus) {
+      const res = mergeExprItems(expr[i - 1], expr[i + 1])
+      if (res !== undefined) {
+        expr.splice(i - 1, 3, res)
+        continue
+      }
+      expr[i++] = "+"
+    }
+    i++
+  }
+}
+
+function mergeExprItems(a: CodeItem, b: CodeItem): CodeItem | undefined {
+  if (b === '""') return a
+  if (a === '""') return b
+  if (typeof a == "string") {
+    if (b instanceof Name || a[a.length - 1] !== '"') return
+    if (typeof b != "string") return `${a.slice(0, -1)}${b}"`
+    if (b[0] === '"') return a.slice(0, -1) + b.slice(1)
+    return
+  }
+  if (typeof b == "string" && b[0] === '"' && !(a instanceof Name)) return `"${a}${b.slice(1)}`
+  return
+}
+
+export function strConcat(c1: Code, c2: Code): Code {
+  return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str`${c1}${c2}`
+}
+
+// TODO do not allow arrays here
+function interpolate(x?: string | string[] | number | boolean | null): SafeExpr | string {
+  return typeof x == "number" || typeof x == "boolean" || x === null
+    ? x
+    : safeStringify(Array.isArray(x) ? x.join(",") : x)
+}
+
+export function stringify(x: unknown): Code {
+  return new _Code(safeStringify(x))
+}
+
+export function safeStringify(x: unknown): string {
+  return JSON.stringify(x)
+    .replace(/\u2028/g, "\\u2028")
+    .replace(/\u2029/g, "\\u2029")
+}
+
+export function getProperty(key: Code | string | number): Code {
+  return typeof key == "string" && IDENTIFIER.test(key) ? new _Code(`.${key}`) : _`[${key}]`
+}
+
+//Does best effort to format the name properly
+export function getEsmExportName(key: Code | string | number): Code {
+  if (typeof key == "string" && IDENTIFIER.test(key)) {
+    return new _Code(`${key}`)
+  }
+  throw new Error(`CodeGen: invalid export name: ${key}, use explicit $id name mapping`)
+}
+
+export function regexpCode(rx: RegExp): Code {
+  return new _Code(rx.toString())
+}