style: 💄 fix linter issues

Author: streamich

src/random/generators.ts

@@ -67,7 +67,9 @@ export const num = (type: NumberType): number => {
   const schema = type.getSchema();
   const {lt, lte, gt, gte} = schema;
   if (gt !== undefined) min = gt;
-  if (gte !== undefined) if (gte === lte) return gte; else min = gte + 0.000000000000001;
+  if (gte !== undefined)
+    if (gte === lte) return gte;
+    else min = gte + 0.000000000000001;
   if (lt !== undefined) max = lt;
   if (lte !== undefined) max = lte - 0.000000000000001;
   if (min >= max) return max;

src/schema/__tests__/SchemaBuilder.spec.ts

@@ -1,4 +1,4 @@
-import {ConstSchema, s} from '..';
+import {type ConstSchema, s} from '..';
 
 describe('string', () => {
   test('can create a string type', () => {

src/schema/index.ts

@@ -1,4 +1,4 @@
-import {TypeOf} from './schema';
+import type {TypeOf} from './schema';
 import {SchemaBuilder} from './SchemaBuilder';
 
 export * from './common';

src/schema/schema.ts

@@ -522,4 +522,4 @@ export type Required<T extends object> = Omit<T, OptionalProps<T>>;
 export type Narrow<T> =
   | (T extends infer U ? U : never)
   | Extract<T, number | string | boolean | bigint | symbol | null | undefined | []>
-  | ([T] extends [[]] ? [] : { [K in keyof T]: Narrow<T[K]> });
+  | ([T] extends [[]] ? [] : {[K in keyof T]: Narrow<T[K]>});

src/type/TypeBuilder.ts

@@ -7,24 +7,22 @@ import type {TypeOfAlias} from '../system/types';
 
 const {s} = schema;
 
-type UnionToIntersection<U> = (
-  U extends never ? never : (arg: U) => never
-) extends (arg: infer I) => void
-  ? I
-  : never;
-
-type UnionToTuple<T> = UnionToIntersection<
-  T extends never ? never : (t: T) => T
-> extends (_: never) => infer W
+type UnionToIntersection<U> = (U extends never ? never : (arg: U) => never) extends (arg: infer I) => void ? I : never;
+
+type UnionToTuple<T> = UnionToIntersection<T extends never ? never : (t: T) => T> extends (_: never) => infer W
   ? [...UnionToTuple<Exclude<T, W>>, W]
   : [];
 
-type ObjValueTuple<T, KS extends any[] = UnionToTuple<keyof T>, R extends any[] = []> =
-  KS extends [infer K, ...infer KT]
+type ObjValueTuple<T, KS extends any[] = UnionToTuple<keyof T>, R extends any[] = []> = KS extends [
+  infer K,
+  ...infer KT,
+]
   ? ObjValueTuple<T, KT, [...R, T[K & keyof T]]>
-  : R
+  : R;
 
-type RecordToFields<O extends Record<string, Type>> = ObjValueTuple<{[K in keyof O]: classes.ObjectFieldType<K extends string ? K : never, O[K]>}>;
+type RecordToFields<O extends Record<string, Type>> = ObjValueTuple<{
+  [K in keyof O]: classes.ObjectFieldType<K extends string ? K : never, O[K]>;
+}>;
 
 export class TypeBuilder {
   constructor(public system?: TypeSystem) {}
@@ -79,7 +77,6 @@ export class TypeBuilder {
     return this.Function$(this.undef, this.undef);
   }
 
-
   // --------------------------------------------------------------- shorthands
 
   public readonly undefined = () => this.undef;
@@ -94,7 +91,10 @@ export class TypeBuilder {
   public readonly literal = this.con;
 
   public readonly array = <T>(type?: T, options?: schema.Optional<schema.ArraySchema>) =>
-    this.Array<T extends Type ? T : classes.AnyType>((type ?? this.any) as T extends Type ? T : classes.AnyType, options);
+    this.Array<T extends Type ? T : classes.AnyType>(
+      (type ?? this.any) as T extends Type ? T : classes.AnyType,
+      options,
+    );
 
   public readonly tuple = <F extends Type[]>(...types: F) => this.Tuple(...types);
 
@@ -131,8 +131,7 @@ export class TypeBuilder {
    * Creates a type that represents a value that may be present or absent. The
    * value is `undefined` if absent. This is a shorthand for `t.Or(type, t.undef)`.
    */
-  public readonly maybe = <T extends Type>(type: T) =>
-    this.Or(type, this.undef);
+  public readonly maybe = <T extends Type>(type: T) => this.Or(type, this.undef);
 
   /**
    * Creates a union type from a list of values. This is a shorthand for
@@ -147,9 +146,10 @@ export class TypeBuilder {
    * @param values The values to include in the union.
    * @returns A union type representing the values.
    */
-  public readonly enum = <const T extends (string | number | boolean | null)[]>(...values: T): classes.OrType<{[K in keyof T]: classes.ConstType<schema.Narrow<T[K]>>}> =>
-    this.Or(...values.map(type => this.Const(type as any))) as any;
-
+  public readonly enum = <const T extends (string | number | boolean | null)[]>(
+    ...values: T
+  ): classes.OrType<{[K in keyof T]: classes.ConstType<schema.Narrow<T[K]>>}> =>
+    this.Or(...values.map((type) => this.Const(type as any))) as any;
 
   // --------------------------------------------------- base node constructors
 
@@ -246,13 +246,21 @@ export class TypeBuilder {
     return type;
   }
 
-  public Function<Req extends Type, Res extends Type>(req: Req, res: Res, options?: schema.Optional<schema.FunctionSchema>) {
+  public Function<Req extends Type, Res extends Type>(
+    req: Req,
+    res: Res,
+    options?: schema.Optional<schema.FunctionSchema>,
+  ) {
     const fn = new classes.FunctionType<Req, Res>(req, res, options);
     fn.system = this.system;
     return fn;
   }
 
-  public Function$<Req extends Type, Res extends Type>(req: Req, res: Res, options?: schema.Optional<schema.FunctionStreamingSchema>) {
+  public Function$<Req extends Type, Res extends Type>(
+    req: Req,
+    res: Res,
+    options?: schema.Optional<schema.FunctionStreamingSchema>,
+  ) {
     const fn = new classes.FunctionStreamingType<Req, Res>(req, res, options);
     fn.system = this.system;
     return fn;

src/type/__tests__/SchemaOf.spec.ts

@@ -1,7 +1,7 @@
 import {EMPTY} from 'rxjs';
 import {type SchemaOf, t} from '..';
 import type {TypeOf} from '../../schema';
-import * as system from '../../system';
+import type * as system from '../../system';
 
 test('const', () => {
   const type = t.Const(<const>42);
@@ -120,30 +120,22 @@ describe('fn', () => {
 });
 
 test('string patch', () => {
-  const StringOperationInsert = t.Tuple(t.Const(1), t.str)
-    .options({
-      title: 'Insert String',
-      description: 'Inserts a string at the current position in the source string.'
-    });
-  const StringOperationEqual = t.Tuple(t.Const(0), t.str)
-    .options({
-      title: 'Equal String',
-      description: 'Keeps the current position in the source string unchanged.'
-    });
-  const StringOperationDelete = t.Tuple(t.Const(-1), t.str)
-    .options({
-      title: 'Delete String',
-      description: 'Deletes the current position in the source string.'
-    });
-  const StringPatch = t.Array(
-    t.Or(
-      StringOperationInsert,
-      StringOperationEqual,
-      StringOperationDelete
-    )
-  ).options({
+  const StringOperationInsert = t.Tuple(t.Const(1), t.str).options({
+    title: 'Insert String',
+    description: 'Inserts a string at the current position in the source string.',
+  });
+  const StringOperationEqual = t.Tuple(t.Const(0), t.str).options({
+    title: 'Equal String',
+    description: 'Keeps the current position in the source string unchanged.',
+  });
+  const StringOperationDelete = t.Tuple(t.Const(-1), t.str).options({
+    title: 'Delete String',
+    description: 'Deletes the current position in the source string.',
+  });
+  const StringPatch = t.Array(t.Or(StringOperationInsert, StringOperationEqual, StringOperationDelete)).options({
     title: 'String Patch',
-    description: 'A list of string operations that can be applied to a source string to produce a destination string, or vice versa.'
+    description:
+      'A list of string operations that can be applied to a source string to produce a destination string, or vice versa.',
   });
 
   type T = system.infer<typeof StringPatch>;
@@ -154,6 +146,6 @@ test('string patch', () => {
   ];
   const v2: T = [
     // @ts-expect-error
-    [2, 'Test']
+    [2, 'Test'],
   ];
 });

src/type/__tests__/TypeBuilder.spec.ts

@@ -76,17 +76,19 @@ test('can construct a realistic object', () => {
 });
 
 test('can build type using lowercase shortcuts', () => {
-  const MyObject = t.object({
-    type: t.con('user'),
-    id: t.string(),
-    name: t.string(),
-    age: t.number(),
-    coordinates: t.tuple(t.number(), t.number()),
-    verified: t.boolean(),
-    offsets: t.array(t.number()),
-    enum: t.enum(1, 2, 'three'),
-    optional: t.maybe(t.string()),
-  }).opt('description', t.string());
+  const MyObject = t
+    .object({
+      type: t.con('user'),
+      id: t.string(),
+      name: t.string(),
+      age: t.number(),
+      coordinates: t.tuple(t.number(), t.number()),
+      verified: t.boolean(),
+      offsets: t.array(t.number()),
+      enum: t.enum(1, 2, 'three'),
+      optional: t.maybe(t.string()),
+    })
+    .opt('description', t.string());
   // console.log(MyObject + '');
   const MyObject2 = t.obj
     .prop('type', t.Const('user'))

src/type/classes/AbstractType.ts

@@ -36,7 +36,7 @@ import {
   type CompiledCapacityEstimator,
 } from '../../codegen/capacity/CapacityEstimatorCodegenContext';
 import {generate} from '../../codegen/capacity/estimators';
-import {TExample} from '../../schema';
+import type {TExample} from '../../schema';
 import type {JsonValueCodec} from '@jsonjoy.com/json-pack/lib/codecs/types';
 import type * as jsonSchema from '../../json-schema';
 import type {BaseType} from '../types';
@@ -112,7 +112,11 @@ export abstract class AbstractType<S extends schema.Schema> implements BaseType<
     return this;
   }
 
-  public example(value: schema.TypeOf<S>, title?: TExample['title'], options?: Omit<TExample, 'value' | 'title'>): this {
+  public example(
+    value: schema.TypeOf<S>,
+    title?: TExample['title'],
+    options?: Omit<TExample, 'value' | 'title'>,
+  ): this {
     const examples = (this.schema.examples ??= []);
     const example: TExample = {...options, value};
     if (typeof title === 'string') example.title = title;

src/type/classes/ArrayType.ts

@@ -17,7 +17,6 @@ import type {json_string} from '@jsonjoy.com/util/lib/json-brand';
 import type * as ts from '../../typescript/types';
 import type {TypeExportContext} from '../../system/TypeExportContext';
 
-
 export class ArrayType<T extends Type> extends AbstractType<schema.ArraySchema<SchemaOf<T>>> {
   protected schema: schema.ArraySchema<any>;
 

src/type/classes/ObjectType.ts

@@ -94,7 +94,10 @@ export class ObjectType<F extends ObjectFieldType<any, any>[] = ObjectFieldType<
     super();
   }
 
-  private _field(field: ObjectFieldType<any, any>, options?: schema.Optional<schema.ObjectFieldSchema<any, any>>): void {
+  private _field(
+    field: ObjectFieldType<any, any>,
+    options?: schema.Optional<schema.ObjectFieldSchema<any, any>>,
+  ): void {
     if (options) field.options(options);
     field.system = this.system;
     this.fields.push(field as any);
@@ -107,7 +110,11 @@ export class ObjectType<F extends ObjectFieldType<any, any>[] = ObjectFieldType<
    * @param options Optional schema options for the property.
    * @returns A new object type with the added property.
    */
-  public prop<K extends string, V extends Type>(key: K, value: V, options?: schema.Optional<schema.ObjectFieldSchema<K, SchemaOf<V>>>): ObjectType<[...F, ObjectFieldType<K, V>]> {
+  public prop<K extends string, V extends Type>(
+    key: K,
+    value: V,
+    options?: schema.Optional<schema.ObjectFieldSchema<K, SchemaOf<V>>>,
+  ): ObjectType<[...F, ObjectFieldType<K, V>]> {
     this._field(new ObjectFieldType<K, V>(key, value), options);
     return <any>this;
   }
@@ -119,7 +126,11 @@ export class ObjectType<F extends ObjectFieldType<any, any>[] = ObjectFieldType<
    * @param options Optional schema options for the property.
    * @returns A new object type with the added property.
    */
-  public opt<K extends string, V extends Type>(key: K, value: V, options?: schema.Optional<schema.ObjectFieldSchema<K, SchemaOf<V>>>): ObjectType<[...F, ObjectOptionalFieldType<K, V>]> {
+  public opt<K extends string, V extends Type>(
+    key: K,
+    value: V,
+    options?: schema.Optional<schema.ObjectFieldSchema<K, SchemaOf<V>>>,
+  ): ObjectType<[...F, ObjectOptionalFieldType<K, V>]> {
     this._field(new ObjectOptionalFieldType<K, V>(key, value), options);
     return <any>this;
   }