From 6555fb80fdd8f6a5d201efadec3189d1244830a0 Mon Sep 17 00:00:00 2001
From: Nevena Bojovic <nenabojov@gmail.com>
Date: Tue, 1 Mar 2022 22:05:25 +0100
Subject: Izbrisala bin, obj i node-modules.

---
 .../node_modules/ajv/lib/compile/jtd/serialize.ts  | 260 ---------------------
 1 file changed, 260 deletions(-)
 delete mode 100644 sandbox/testAppNevena/Front/node_modules/ajv/lib/compile/jtd/serialize.ts

(limited to 'sandbox/testAppNevena/Front/node_modules/ajv/lib/compile/jtd/serialize.ts')

diff --git a/sandbox/testAppNevena/Front/node_modules/ajv/lib/compile/jtd/serialize.ts b/sandbox/testAppNevena/Front/node_modules/ajv/lib/compile/jtd/serialize.ts
deleted file mode 100644
index a8b36bd8..00000000
--- a/sandbox/testAppNevena/Front/node_modules/ajv/lib/compile/jtd/serialize.ts
+++ /dev/null
@@ -1,260 +0,0 @@
-import type Ajv from "../../core"
-import type {SchemaObject} from "../../types"
-import {jtdForms, JTDForm, SchemaObjectMap} from "./types"
-import {SchemaEnv, getCompilingSchema} from ".."
-import {_, str, and, getProperty, CodeGen, Code, Name} from "../codegen"
-import MissingRefError from "../ref_error"
-import N from "../names"
-import {isOwnProperty} from "../../vocabularies/code"
-import {hasRef} from "../../vocabularies/jtd/ref"
-import {useFunc} from "../util"
-import quote from "../../runtime/quote"
-
-const genSerialize: {[F in JTDForm]: (cxt: SerializeCxt) => void} = {
-  elements: serializeElements,
-  values: serializeValues,
-  discriminator: serializeDiscriminator,
-  properties: serializeProperties,
-  optionalProperties: serializeProperties,
-  enum: serializeString,
-  type: serializeType,
-  ref: serializeRef,
-}
-
-interface SerializeCxt {
-  readonly gen: CodeGen
-  readonly self: Ajv // current Ajv instance
-  readonly schemaEnv: SchemaEnv
-  readonly definitions: SchemaObjectMap
-  schema: SchemaObject
-  data: Code
-}
-
-export default function compileSerializer(
-  this: Ajv,
-  sch: SchemaEnv,
-  definitions: SchemaObjectMap
-): SchemaEnv {
-  const _sch = getCompilingSchema.call(this, sch)
-  if (_sch) return _sch
-  const {es5, lines} = this.opts.code
-  const {ownProperties} = this.opts
-  const gen = new CodeGen(this.scope, {es5, lines, ownProperties})
-  const serializeName = gen.scopeName("serialize")
-  const cxt: SerializeCxt = {
-    self: this,
-    gen,
-    schema: sch.schema as SchemaObject,
-    schemaEnv: sch,
-    definitions,
-    data: N.data,
-  }
-
-  let sourceCode: string | undefined
-  try {
-    this._compilations.add(sch)
-    sch.serializeName = serializeName
-    gen.func(serializeName, N.data, false, () => {
-      gen.let(N.json, str``)
-      serializeCode(cxt)
-      gen.return(N.json)
-    })
-    gen.optimize(this.opts.code.optimize)
-    const serializeFuncCode = gen.toString()
-    sourceCode = `${gen.scopeRefs(N.scope)}return ${serializeFuncCode}`
-    const makeSerialize = new Function(`${N.scope}`, sourceCode)
-    const serialize: (data: unknown) => string = makeSerialize(this.scope.get())
-    this.scope.value(serializeName, {ref: serialize})
-    sch.serialize = serialize
-  } catch (e) {
-    if (sourceCode) this.logger.error("Error compiling serializer, function code:", sourceCode)
-    delete sch.serialize
-    delete sch.serializeName
-    throw e
-  } finally {
-    this._compilations.delete(sch)
-  }
-  return sch
-}
-
-function serializeCode(cxt: SerializeCxt): void {
-  let form: JTDForm | undefined
-  for (const key of jtdForms) {
-    if (key in cxt.schema) {
-      form = key
-      break
-    }
-  }
-  serializeNullable(cxt, form ? genSerialize[form] : serializeEmpty)
-}
-
-function serializeNullable(cxt: SerializeCxt, serializeForm: (_cxt: SerializeCxt) => void): void {
-  const {gen, schema, data} = cxt
-  if (!schema.nullable) return serializeForm(cxt)
-  gen.if(
-    _`${data} === undefined || ${data} === null`,
-    () => gen.add(N.json, _`"null"`),
-    () => serializeForm(cxt)
-  )
-}
-
-function serializeElements(cxt: SerializeCxt): void {
-  const {gen, schema, data} = cxt
-  gen.add(N.json, str`[`)
-  const first = gen.let("first", true)
-  gen.forOf("el", data, (el) => {
-    addComma(cxt, first)
-    serializeCode({...cxt, schema: schema.elements, data: el})
-  })
-  gen.add(N.json, str`]`)
-}
-
-function serializeValues(cxt: SerializeCxt): void {
-  const {gen, schema, data} = cxt
-  gen.add(N.json, str`{`)
-  const first = gen.let("first", true)
-  gen.forIn("key", data, (key) => serializeKeyValue(cxt, key, schema.values, first))
-  gen.add(N.json, str`}`)
-}
-
-function serializeKeyValue(cxt: SerializeCxt, key: Name, schema: SchemaObject, first: Name): void {
-  const {gen, data} = cxt
-  addComma(cxt, first)
-  serializeString({...cxt, data: key})
-  gen.add(N.json, str`:`)
-  const value = gen.const("value", _`${data}${getProperty(key)}`)
-  serializeCode({...cxt, schema, data: value})
-}
-
-function serializeDiscriminator(cxt: SerializeCxt): void {
-  const {gen, schema, data} = cxt
-  const {discriminator} = schema
-  gen.add(N.json, str`{${JSON.stringify(discriminator)}:`)
-  const tag = gen.const("tag", _`${data}${getProperty(discriminator)}`)
-  serializeString({...cxt, data: tag})
-  gen.if(false)
-  for (const tagValue in schema.mapping) {
-    gen.elseIf(_`${tag} === ${tagValue}`)
-    const sch = schema.mapping[tagValue]
-    serializeSchemaProperties({...cxt, schema: sch}, discriminator)
-  }
-  gen.endIf()
-  gen.add(N.json, str`}`)
-}
-
-function serializeProperties(cxt: SerializeCxt): void {
-  const {gen} = cxt
-  gen.add(N.json, str`{`)
-  serializeSchemaProperties(cxt)
-  gen.add(N.json, str`}`)
-}
-
-function serializeSchemaProperties(cxt: SerializeCxt, discriminator?: string): void {
-  const {gen, schema, data} = cxt
-  const {properties, optionalProperties} = schema
-  const props = keys(properties)
-  const optProps = keys(optionalProperties)
-  const allProps = allProperties(props.concat(optProps))
-  let first = !discriminator
-  for (const key of props) {
-    serializeProperty(key, properties[key], keyValue(key))
-  }
-  for (const key of optProps) {
-    const value = keyValue(key)
-    gen.if(and(_`${value} !== undefined`, isOwnProperty(gen, data, key)), () =>
-      serializeProperty(key, optionalProperties[key], value)
-    )
-  }
-  if (schema.additionalProperties) {
-    gen.forIn("key", data, (key) =>
-      gen.if(isAdditional(key, allProps), () =>
-        serializeKeyValue(cxt, key, {}, gen.let("first", first))
-      )
-    )
-  }
-
-  function keys(ps?: SchemaObjectMap): string[] {
-    return ps ? Object.keys(ps) : []
-  }
-
-  function allProperties(ps: string[]): string[] {
-    if (discriminator) ps.push(discriminator)
-    if (new Set(ps).size !== ps.length) {
-      throw new Error("JTD: properties/optionalProperties/disciminator overlap")
-    }
-    return ps
-  }
-
-  function keyValue(key: string): Name {
-    return gen.const("value", _`${data}${getProperty(key)}`)
-  }
-
-  function serializeProperty(key: string, propSchema: SchemaObject, value: Name): void {
-    if (first) first = false
-    else gen.add(N.json, str`,`)
-    gen.add(N.json, str`${JSON.stringify(key)}:`)
-    serializeCode({...cxt, schema: propSchema, data: value})
-  }
-
-  function isAdditional(key: Name, ps: string[]): Code | true {
-    return ps.length ? and(...ps.map((p) => _`${key} !== ${p}`)) : true
-  }
-}
-
-function serializeType(cxt: SerializeCxt): void {
-  const {gen, schema, data} = cxt
-  switch (schema.type) {
-    case "boolean":
-      gen.add(N.json, _`${data} ? "true" : "false"`)
-      break
-    case "string":
-      serializeString(cxt)
-      break
-    case "timestamp":
-      gen.if(
-        _`${data} instanceof Date`,
-        () => gen.add(N.json, _`'"' + ${data}.toISOString() + '"'`),
-        () => serializeString(cxt)
-      )
-      break
-    default:
-      serializeNumber(cxt)
-  }
-}
-
-function serializeString({gen, data}: SerializeCxt): void {
-  gen.add(N.json, _`${useFunc(gen, quote)}(${data})`)
-}
-
-function serializeNumber({gen, data}: SerializeCxt): void {
-  gen.add(N.json, _`"" + ${data}`)
-}
-
-function serializeRef(cxt: SerializeCxt): void {
-  const {gen, self, data, definitions, schema, schemaEnv} = cxt
-  const {ref} = schema
-  const refSchema = definitions[ref]
-  if (!refSchema) throw new MissingRefError("", ref, `No definition ${ref}`)
-  if (!hasRef(refSchema)) return serializeCode({...cxt, schema: refSchema})
-  const {root} = schemaEnv
-  const sch = compileSerializer.call(self, new SchemaEnv({schema: refSchema, root}), definitions)
-  gen.add(N.json, _`${getSerialize(gen, sch)}(${data})`)
-}
-
-function getSerialize(gen: CodeGen, sch: SchemaEnv): Code {
-  return sch.serialize
-    ? gen.scopeValue("serialize", {ref: sch.serialize})
-    : _`${gen.scopeValue("wrapper", {ref: sch})}.serialize`
-}
-
-function serializeEmpty({gen, data}: SerializeCxt): void {
-  gen.add(N.json, _`JSON.stringify(${data})`)
-}
-
-function addComma({gen}: SerializeCxt, first: Name): void {
-  gen.if(
-    first,
-    () => gen.assign(first, false),
-    () => gen.add(N.json, str`,`)
-  )
-}
-- 
cgit v1.2.3