@naturalcycles/js-lib 15.46.0 → 15.47.0

package/src/json-schema/index.ts

@@ -1,5 +0,0 @@
-export * from './from-data/generateJsonSchemaFromData.js'
-export * from './jsonSchema.cnst.js'
-export * from './jsonSchema.model.js'
-export * from './jsonSchema.util.js'
-export * from './jsonSchemaBuilder.js'

package/src/json-schema/jsonSchema.cnst.ts

@@ -1,52 +0,0 @@
-import type {
-  JsonSchema,
-  JsonSchemaAny,
-  JsonSchemaNumber,
-  JsonSchemaObject,
-  JsonSchemaString,
-} from './jsonSchema.model.js'
-
-export const JSON_SCHEMA_ORDER: (
-  | keyof JsonSchema
-  | keyof JsonSchemaAny
-  | keyof JsonSchemaObject
-  | keyof JsonSchemaString
-  | keyof JsonSchemaNumber
-)[] = [
-  '$schema',
-  '$id',
-  'title',
-  'description',
-  'deprecated',
-  'readOnly',
-  'writeOnly',
-  'type',
-  'default',
-  // Object,
-  'properties',
-  'required',
-  'minProperties',
-  'maxProperties',
-  'patternProperties',
-  'propertyNames',
-  // Array
-  'properties',
-  'required',
-  'minProperties',
-  'maxProperties',
-  'patternProperties',
-  'propertyNames',
-  // String
-  'pattern',
-  'minLength',
-  'maxLength',
-  'format',
-  'transform',
-  // Number
-  'format',
-  'multipleOf',
-  'minimum',
-  'exclusiveMinimum',
-  'maximum',
-  'exclusiveMaximum',
-]

package/src/json-schema/jsonSchema.model.ts

@@ -1,172 +0,0 @@
-import type { AnyObject, StringMap } from '../types.js'
-
-export type JsonSchema<T = unknown> =
-  | JsonSchemaAny<T>
-  | JsonSchemaOneOf<T>
-  | JsonSchemaAllOf<T>
-  | JsonSchemaAnyOf<T>
-  | JsonSchemaNot<T>
-  | JsonSchemaRef<T>
-  | JsonSchemaConst<T>
-  | JsonSchemaEnum<T>
-  | JsonSchemaString
-  | JsonSchemaNumber
-  | JsonSchemaBoolean
-  | JsonSchemaNull
-  | JsonSchemaObject<T extends AnyObject ? T : AnyObject>
-  | JsonSchemaArray<T>
-  | JsonSchemaTuple<T>
-
-export interface JsonSchemaAny<T = unknown> {
-  $schema?: string
-  $id?: string
-  title?: string
-  description?: string
-  // $comment?: string
-  // nullable?: boolean // not sure about that field
-  deprecated?: boolean
-  readOnly?: boolean
-  writeOnly?: boolean
-
-  type?: string | string[]
-
-  default?: T
-
-  // https://json-schema.org/understanding-json-schema/reference/conditionals.html#id6
-  if?: JsonSchema
-  then?: JsonSchema
-  else?: JsonSchema
-
-  /**
-   * https://ajv.js.org/packages/ajv-keywords.html#instanceof
-   *
-   * Useful for Node.js Buffer, you can use it like:
-   * `instanceof: 'Buffer'`
-   */
-  instanceof?: string | string[]
-
-  /**
-   * This is a temporary "intermediate AST" field that is used inside the parser.
-   * In the final schema this field will NOT be present.
-   */
-  optionalField?: true
-}
-
-/**
- * Union type
- */
-export interface JsonSchemaOneOf<T = unknown> extends JsonSchemaAny<T> {
-  oneOf: JsonSchema[]
-}
-
-/**
- * Intersection type
- */
-export interface JsonSchemaAllOf<T = unknown> extends JsonSchemaAny<T> {
-  allOf: JsonSchema[]
-}
-
-export interface JsonSchemaAnyOf<T = unknown> extends JsonSchemaAny<T> {
-  anyOf: JsonSchema[]
-}
-
-export interface JsonSchemaNot<T = unknown> extends JsonSchemaAny<T> {
-  not: JsonSchema
-}
-
-// Trying to loosen the type restrictions, to make things simpler. To be monitored!
-// export interface JsonSchemaConst<T extends string | number | boolean = any>
-export interface JsonSchemaConst<T = unknown> extends JsonSchemaAny<T> {
-  const: T // literal type
-}
-
-export interface JsonSchemaString<T extends string = string> extends JsonSchemaAny<T> {
-  type: 'string'
-  pattern?: string
-  minLength?: number
-  maxLength?: number
-  format?: string
-
-  contentMediaType?: string
-  contentEncoding?: string // e.g 'base64'
-
-  /**
-   * https://ajv.js.org/packages/ajv-keywords.html#transform
-   */
-  transform?: ('trim' | 'toLowerCase' | 'toUpperCase')[]
-}
-
-export interface JsonSchemaNumber<T extends number = number> extends JsonSchemaAny<T> {
-  type: 'number' | 'integer'
-  format?: string
-  multipleOf?: number
-  minimum?: number
-  exclusiveMinimum?: number
-  maximum?: number
-  exclusiveMaximum?: number
-}
-
-export interface JsonSchemaBoolean extends JsonSchemaAny<boolean> {
-  type: 'boolean'
-}
-
-export interface JsonSchemaNull extends JsonSchemaAny<null> {
-  type: 'null'
-}
-
-// export interface JsonSchemaEnum<T extends string | number = any> extends JsonSchemaAny<T> {
-export interface JsonSchemaEnum<T = unknown> extends JsonSchemaAny<T> {
-  enum: T[]
-}
-
-export interface JsonSchemaRef<T = unknown> extends JsonSchemaAny<T> {
-  $ref: string
-}
-
-export interface JsonSchemaRootObject<T extends AnyObject = AnyObject> extends JsonSchemaObject<T> {
-  $id: string
-}
-
-export interface JsonSchemaObject<T extends AnyObject = AnyObject> extends JsonSchemaAny<T> {
-  type: 'object'
-  // let's be strict and require all these
-  properties: {
-    [k in keyof T]: JsonSchema
-  }
-  required: (keyof T)[]
-  additionalProperties: boolean
-  minProperties?: number
-  maxProperties?: number
-
-  // StringMap
-  patternProperties?: StringMap<JsonSchema>
-  propertyNames?: JsonSchema
-
-  /**
-   * @example
-   *
-   * dependentRequired: {
-   *   credit_card: ['billing_address']
-   * }
-   */
-  dependentRequired?: StringMap<string[]>
-
-  dependentSchemas?: StringMap<JsonSchema>
-
-  dependencies?: StringMap<string[]>
-}
-
-export interface JsonSchemaArray<ITEM = unknown> extends JsonSchemaAny<ITEM[]> {
-  type: 'array'
-  items: JsonSchema<ITEM>
-  minItems?: number
-  maxItems?: number
-  uniqueItems?: boolean
-}
-
-export interface JsonSchemaTuple<T = unknown> extends JsonSchemaAny<T> {
-  type: 'array'
-  items: JsonSchema[]
-  minItems: number
-  maxItems: number
-}

package/src/json-schema/jsonSchema.util.ts

@@ -1,36 +0,0 @@
-import { _uniq } from '../array/array.util.js'
-import { _filterNullishValues } from '../object/object.util.js'
-import type { AnyObject } from '../types.js'
-import type { JsonSchemaObject } from './jsonSchema.model.js'
-
-/**
- * Merges s2 into s1 (mutates s1) and returns s1.
- * Does not mutate s2.
- * API similar to Object.assign(s1, s2)
- */
-export function mergeJsonSchemaObjects<T1 extends AnyObject, T2 extends AnyObject>(
-  s1: JsonSchemaObject<T1>,
-  s2: JsonSchemaObject<T2>,
-): JsonSchemaObject<T1 & T2> {
-  // Merge `properties`
-  Object.entries(s2.properties).forEach(([k, v]) => {
-    ;(s1.properties as any)[k] = v
-  })
-
-  // Merge `patternProperties`
-  Object.entries(s2.patternProperties || {}).forEach(([k, v]) => {
-    ;(s1.patternProperties as any)[k] = v
-  })
-
-  s1.propertyNames = s2.propertyNames || s1.propertyNames
-  s1.minProperties = s2.minProperties ?? s1.minProperties
-  s1.maxProperties = s2.maxProperties ?? s1.maxProperties
-
-  // Merge `required`
-  s1.required.push(...(s2.required as any))
-  s1.required = _uniq(s1.required).sort()
-
-  // `additionalProperties` remains the same
-
-  return _filterNullishValues(s1, { mutate: true }) as any
-}