schematox 1.2.2 → 1.2.3

package/src/tests/fixtures.ts

@@ -1,53 +0,0 @@
-export const DATA_TYPE = [
-  ['boolean', [true, false]],
-  ['literal', []], // added to be consistent with `foldC`
-  ['number', [-1, -0.001, 0, 0.001, 1]],
-  ['bigint', [BigInt(12)]],
-  ['string', ['', 'x', 'xy', 'xyz']],
-  [
-    'binary',
-    [
-      // TODO: jest complains after #52 PR merge
-      // new Blob(),
-      new File([''], 'filename'),
-      new ArrayBuffer(0),
-      new DataView(new ArrayBuffer(0)),
-      new Int8Array(),
-      new Uint8Array(),
-      new Uint8ClampedArray(),
-      new Int16Array(),
-      new Uint16Array(),
-      new Int32Array(),
-      new Uint32Array(),
-      new Float32Array(),
-      new Float64Array(),
-    ],
-  ],
-  //
-  ['null', [null]],
-  ['NaN', [NaN]],
-  ['undefined', [undefined]],
-  ['infinity', [Infinity, -Infinity]],
-  ['symbol', [Symbol('x'), Symbol('y')]],
-  //
-  ['array', [[], ['x', 'y']]],
-  ['object', [{}, { x: 'y' }]],
-  ['record', []], // added to be consistent with `foldC`
-  ['union', []], // added to be consistent with `foldC`
-  ['tuple', []], // added to be consistent with `foldC`
-  ['set', [new Set(), new WeakSet()]],
-  ['map', [new Map(), new WeakMap()]],
-  ['error', [new Error()]],
-] as const satisfies Array<[type: string, variants: unknown[]]>
-
-export const DATA_VARIANTS_BY_TYPE = DATA_TYPE.reduce<
-  Record<string, unknown[]>
->((acc, [type, variants]) => {
-  acc[type] = variants
-  return acc
-}, {}) as {
-  [K in (typeof DATA_TYPE)[number][0]]: Extract<
-    (typeof DATA_TYPE)[number],
-    [K, unknown]
-  >[1]
-}

package/src/tests/fold-constants.ts

@@ -1,247 +0,0 @@
-/* FOLDS must be in sync with `src/tests/README.md` */
-
-const FOLD_A = `{
-  const construct = x.makeStruct(schema)
-
-  /* ensure that schema/construct/struct/~standard subject types are identical */
-
-  type ConstructSchemaSubj = x.Infer<typeof construct.__schema>
-
-  x.tCh<ConstructSchemaSubj, ExpectedSubj>()
-  x.tCh<ExpectedSubj, ConstructSchemaSubj>()
-
-  type SchemaSubj = x.Infer<typeof schema>
-
-  x.tCh<SchemaSubj, ExpectedSubj>()
-  x.tCh<ExpectedSubj, SchemaSubj>()
-
-  type StructSubj = x.Infer<typeof struct.__schema>
-
-  x.tCh<StructSubj, ExpectedSubj>()
-  x.tCh<ExpectedSubj, StructSubj>()
-
-  type StandardSubj = NonNullable<
-    (typeof struct)['~standard']['types']
-  >['output']
-
-  x.tCh<StandardSubj, ExpectedSubj>()
-  x.tCh<ExpectedSubj, StandardSubj>()
-
-  /* parsed either type check */
-
-  type ExpectedParsed = x.ParseResult<ExpectedSubj>
-
-  const parsed = x.parse(schema, undefined)
-
-  type SchemaParsed = typeof parsed
-
-  x.tCh<SchemaParsed, ExpectedParsed>()
-  x.tCh<ExpectedParsed, SchemaParsed>()
-
-  type ConstructParsed = ReturnType<typeof construct.parse>
-
-  x.tCh<ConstructParsed, ExpectedParsed>()
-  x.tCh<ExpectedParsed, ConstructParsed>()
-
-  type StructParsed = ReturnType<typeof struct.parse>
-
-  x.tCh<StructParsed, ExpectedParsed>()
-  x.tCh<ExpectedParsed, StructParsed>()
-
-  type StandardParsed = Extract<
-    ReturnType<(typeof struct)['~standard']['validate']>,
-    { value: unknown }
-  >['value']
-
-  x.tCh<StandardParsed, ExpectedSubj>()
-  x.tCh<ExpectedSubj, StandardParsed>()
-
-  /* runtime schema check */
-
-  expect(struct.__schema).toStrictEqual(schema)
-  expect(construct.__schema).toStrictEqual(schema)
-  expect(construct.__schema === schema).toBe(false)
-
-  /* parse result check */
-
-  for (const subj of subjects) {
-    const schemaParsed = x.parse(schema, subj)
-
-    expect(schemaParsed.error).toBe(undefined)
-    expect(schemaParsed.data).toStrictEqual(subj)
-
-    const constructParsed = construct.parse(subj)
-
-    expect(constructParsed.error).toBe(undefined)
-    expect(constructParsed.data).toStrictEqual(subj)
-
-    const structParsed = struct.parse(subj)
-
-    expect(structParsed.error).toBe(undefined)
-    expect(structParsed.data).toStrictEqual(subj)
-
-    const standardParsed = struct['~standard'].validate(subj)
-
-    if (standardParsed instanceof Promise) {
-      throw Error('Not expected')
-    }
-
-    if (standardParsed.issues !== undefined) {
-      throw Error('not expected')
-    }
-
-    expect(standardParsed.value).toStrictEqual(subj)
-  }
-}`
-
-const FOLD_B = `{
-  const construct = x.makeStruct(schema)
-
-  /* ensure that struct keys are reduced after application */
-
-  type StructKeys = keyof typeof struct
-
-  x.tCh<StructKeys, ExpectedKeys>()
-  x.tCh<ExpectedKeys, StructKeys>()
-
-  type ConstructKeys = keyof typeof construct
-
-  x.tCh<ConstructKeys, ExpectedKeys>()
-  x.tCh<ExpectedKeys, ConstructKeys>()
-
-  /* ensure that construct/struct schema types are identical  */
-
-  type ExpectedSchema = typeof schema
-  type StructSchema = typeof struct.__schema
-
-  x.tCh<StructSchema, ExpectedSchema>()
-  x.tCh<ExpectedSchema, StructSchema>()
-
-  type ConstructSchema = typeof struct.__schema
-
-  x.tCh<ConstructSchema, ExpectedSchema>()
-  x.tCh<ExpectedSchema, ConstructSchema>()
-
-  /* runtime schema check */
-
-  expect(struct.__schema).toStrictEqual(schema)
-  expect(construct.__schema).toStrictEqual(schema)
-  expect(construct.__schema === schema).toBe(false)
-
-  /* runtime schema parameter application immutability check */
-
-  expect(prevStruct.__schema === struct.__schema).toBe(false)
-}`
-
-const FOLD_C = `{
-  const construct = x.makeStruct(schema)
-
-  for (const [kind, types] of source) {
-    if (kind === schema.type) {
-      continue
-    }
-
-    for (const subject of types) {
-      const expectedError = [
-        {
-          code: x.ERROR_CODE.invalidType,
-          schema: schema,
-          subject: subject,
-          path: [],
-        },
-      ]
-
-      const parsedSchema = x.parse(schema, subject)
-      const parsedConstruct = construct.parse(subject)
-      const parsedStruct = struct.parse(subject)
-
-      expect(parsedSchema.error).toStrictEqual(expectedError)
-      expect(parsedConstruct.error).toStrictEqual(expectedError)
-      expect(parsedStruct.error).toStrictEqual(expectedError)
-
-      const parsedStandard = struct['~standard'].validate(subject)
-
-      if (parsedStandard instanceof Promise) {
-        throw Error('Not expected')
-      }
-
-      expect(parsedStandard.issues).toStrictEqual([
-        { message: x.ERROR_CODE.invalidType, path: [] },
-      ])
-    }
-  }
-}`
-
-const FOLD_D = `{
-  const construct = x.makeStruct(schema)
-
-  for (const subject of subjects) {
-    const expectedError = [
-      {
-        code: x.ERROR_CODE.invalidRange,
-        schema: schema,
-        subject: subject,
-        path: [],
-      },
-    ]
-
-    const parsedSchema = x.parse(schema, subject)
-    const parsedConstruct = construct.parse(subject)
-    const parsedStruct = struct.parse(subject)
-
-    expect(parsedSchema.error).toStrictEqual(expectedError)
-    expect(parsedConstruct.error).toStrictEqual(expectedError)
-    expect(parsedStruct.error).toStrictEqual(expectedError)
-
-    const parsedStandard = struct['~standard'].validate(subject)
-
-    if (parsedStandard instanceof Promise) {
-      throw Error('Not expected')
-    }
-
-    expect(parsedStandard.issues).toStrictEqual([
-      { message: x.ERROR_CODE.invalidRange, path: [] },
-    ])
-  }
-}`
-
-const FOLD_E = `{
-  const construct = x.makeStruct(schema)
-
-  for (const [subject, invalidSubj, invalidSubjSchema, path] of samples) {
-    const expectedError = [
-      {
-        path,
-        code: x.ERROR_CODE.invalidType,
-        schema: invalidSubjSchema,
-        subject: invalidSubj,
-      },
-    ]
-
-    const parsedSchema = x.parse(schema, subject)
-    const parsedConstruct = construct.parse(subject)
-    const parsedStruct = struct.parse(subject)
-
-    expect(parsedSchema.error).toStrictEqual(expectedError)
-    expect(parsedConstruct.error).toStrictEqual(expectedError)
-    expect(parsedStruct.error).toStrictEqual(expectedError)
-
-    const parsedStandard = struct['~standard'].validate(subject)
-
-    if (parsedStandard instanceof Promise) {
-      throw Error('Not expected')
-    }
-
-    expect(parsedStandard.issues).toStrictEqual([
-      { path, message: x.ERROR_CODE.invalidType },
-    ])
-  }
-}`
-
-export const FOLDS: Array<[label: string, content: string]> = [
-  ['foldA', FOLD_A],
-  ['foldB', FOLD_B],
-  ['foldC', FOLD_C],
-  ['foldD', FOLD_D],
-  ['foldE', FOLD_E],
-]

package/src/tests/fold-morph.ts

@@ -1,49 +0,0 @@
-import { Project, SyntaxKind } from 'ts-morph'
-import { FOLDS } from './fold-constants'
-
-const FILE_PATHS = [
-  'src/tests/by-struct/boolean.test.ts',
-  'src/tests/by-struct/literal.test.ts',
-  'src/tests/by-struct/number.test.ts',
-  'src/tests/by-struct/string.test.ts',
-  //
-  'src/tests/by-struct/array.test.ts',
-  'src/tests/by-struct/object.test.ts',
-  'src/tests/by-struct/record.test.ts',
-  'src/tests/by-struct/tuple.test.ts',
-  'src/tests/by-struct/union.test.ts',
-]
-
-for (const filePath of FILE_PATHS) {
-  for (const [foldLabel, foldContent] of FOLDS) {
-    foldSync({ filePath, foldLabel, foldContent })
-  }
-}
-
-function foldSync(props: {
-  filePath: string
-  foldLabel: string
-  foldContent: string
-}) {
-  const project = new Project()
-  const sourceFile = project.addSourceFileAtPath(props.filePath)
-
-  const labeledStatements = sourceFile.getDescendantsOfKind(
-    SyntaxKind.LabeledStatement
-  )
-
-  for (const labeledStatement of labeledStatements) {
-    const label = labeledStatement.getLabel()
-
-    if (label.getText() === props.foldLabel) {
-      const statement = labeledStatement.getStatement()
-
-      if (statement.getKind() === SyntaxKind.Block) {
-        const blockStatement = statement.asKindOrThrow(SyntaxKind.Block)
-        blockStatement.replaceWithText(props.foldContent)
-      }
-    }
-  }
-
-  sourceFile.saveSync()
-}

package/src/tests/type.ts

@@ -1 +0,0 @@
-export type StructSharedKeys = '__schema' | '~standard' | 'parse'

package/src/tests/types/extensions.test.ts

@@ -1,117 +0,0 @@
-import * as x from '../../index'
-
-describe('ExtWith_SchemaParams_SubjT<T, U>: U is primitive', () => {
-  type U = boolean
-
-  it('extend nothing if parameters are not specified', () => {
-    const schema = {} as const
-
-    type Expected = U
-    type Actual = x.ExtendParams<typeof schema, U>
-
-    x.tCh<Expected, Actual>()
-    x.tCh<Actual, Expected>()
-  })
-
-  it('optional', () => {
-    const schema = { optional: true } as const
-
-    type Expected = U | undefined
-    type Actual = x.ExtendParams<typeof schema, U>
-
-    x.tCh<Actual, Expected>()
-    x.tCh<Expected, Actual>()
-  })
-
-  it('nullable', () => {
-    const schema = { nullable: true } as const
-
-    type Expected = U | null
-    type Actual = x.ExtendParams<typeof schema, U>
-
-    x.tCh<Actual, Expected>()
-    x.tCh<Expected, Actual>()
-  })
-
-  it('brand', () => {
-    const schema = { brand: ['x', 'y'] } as const
-
-    type Expected = U & { __x: 'y' }
-    type Actual = x.ExtendParams<typeof schema, U>
-
-    x.tCh<Actual, Expected>()
-    x.tCh<Expected, Actual>()
-  })
-
-  it('optional + nullable + brand', () => {
-    const schema = {
-      optional: true,
-      nullable: true,
-      brand: ['x', 'y'],
-    } as const
-
-    type Expected = (U & { __x: 'y' }) | null | undefined
-    type Actual = x.ExtendParams<typeof schema, U>
-
-    x.tCh<Actual, Expected>()
-    x.tCh<Expected, Actual>()
-  })
-})
-
-describe('ExtWith_SchemaParams_SubjT<T, U>: U is object', () => {
-  type U = { x: string; y: number }
-
-  it('extend nothing if parameters are not specified', () => {
-    const schema = {} as const
-
-    type Expected = U
-    type Actual = x.ExtendParams<typeof schema, U>
-
-    x.tCh<Actual, Expected>()
-    x.tCh<Expected, Actual>()
-  })
-
-  it('optional', () => {
-    const schema = { optional: true } as const
-
-    type Expected = U | undefined
-    type Actual = x.ExtendParams<typeof schema, U>
-
-    x.tCh<Actual, Expected>()
-    x.tCh<Expected, Actual>()
-  })
-
-  it('nullable', () => {
-    const schema = { nullable: true } as const
-
-    type Expected = U | null
-    type Actual = x.ExtendParams<typeof schema, U>
-
-    x.tCh<Actual, Expected>()
-    x.tCh<Expected, Actual>()
-  })
-
-  it('brand', () => {
-    const schema = { brand: ['x', 'y'] } as const
-
-    type Expected = U & { __x: 'y' }
-    type Actual = x.ExtendParams<typeof schema, U>
-
-    x.tCh<Actual, Expected>()
-    x.tCh<Expected, Actual>()
-  })
-
-  it('optional + nullable + brand', () => {
-    const schema = {
-      optional: true,
-      nullable: true,
-      brand: ['x', 'y'],
-    } as const
-
-    type Expected = (U & { __x: 'y' }) | null | undefined
-    type Actual = x.ExtendParams<typeof schema, U>
-
-    x.tCh<Actual, Expected>()
-    x.tCh<Expected, Actual>()
-  })
-})