@strictly/define 0.0.1 → 0.0.2

package/types/flattened_value_types_of.ts

@@ -1,11 +0,0 @@
-import { type Type } from './definitions'
-import { type FlattenedTypeDefsOf } from './flattened_type_defs_of'
-import { type ValueTypeOf } from './value_type_of'
-
-export type FlattenedValueTypesOf<
-  T extends Type,
-  SegmentOverride extends string | null = null,
-  Flattened extends Readonly<Record<string, Type>> = FlattenedTypeDefsOf<T, SegmentOverride>,
-> = {
-  [K in keyof Flattened]: ValueTypeOf<Flattened[K], {}>
-}

package/types/readonly_type_def_of.ts

@@ -1,53 +0,0 @@
-import {
-  type ListTypeDef,
-  type LiteralTypeDef,
-  type ObjectTypeDef,
-  type RecordTypeDef,
-  type Type,
-  type TypeDef,
-  type UnionTypeDef,
-} from './definitions'
-
-export type ReadonlyTypeDefOf<T extends Type> = {
-  readonly definition: InternalReadonlyTypeDefOf<T['definition']>,
-}
-
-type InternalReadonlyTypeDefOf<T extends TypeDef> = T extends LiteralTypeDef ? InternalReadonlyTypeDefOfLiteral<T>
-  : T extends ListTypeDef ? InternalReadonlyTypeDefOfList<T>
-  : T extends RecordTypeDef ? InternalReadonlyTypeDefOfRecord<T>
-  : T extends ObjectTypeDef ? InternalReadonlyTypeDefOfObject<T>
-  : T extends UnionTypeDef ? InternalReadonlyTypeDefOfUnion<T>
-  : never
-
-type InternalReadonlyTypeDefOfLiteral<T extends LiteralTypeDef> = T
-
-type InternalReadonlyTypeDefOfList<T extends ListTypeDef> = {
-  readonly type: T['type'],
-  readonly elements: InternalReadonlyTypeDefOf<T['elements']>,
-}
-
-type InternalReadonlyTypeDefOfRecord<T extends RecordTypeDef> = {
-  readonly type: T['type'],
-  readonly keyPrototype: T['keyPrototype'],
-  readonly valueTypeDef: undefined extends T['valueTypeDef'] ? InternalReadonlyTypeDefOf<
-      Exclude<T['valueTypeDef'], undefined>
-    > | undefined
-    : InternalReadonlyTypeDefOf<T['valueTypeDef']>,
-}
-
-type InternalReadonlyTypeDefOfObject<T extends ObjectTypeDef> = T extends ObjectTypeDef<infer Fields> ? {
-    readonly type: T['type'],
-    readonly fields: {
-      readonly [K in keyof Fields]: InternalReadonlyTypeDefOf<Fields[K]>
-    },
-  }
-  : never
-
-type InternalReadonlyTypeDefOfUnion<T extends UnionTypeDef> = T extends UnionTypeDef<infer D, infer Unions> ? {
-    readonly type: T['type'],
-    readonly discriminator: D,
-    readonly unions: {
-      readonly [K in keyof Unions]: InternalReadonlyTypeDefOf<Unions[K]>
-    },
-  }
-  : never

package/types/specs/flattened_value_types_of.tests.ts

@@ -1,21 +0,0 @@
-import {
-  numberType,
-  record,
-} from 'types/builders'
-import { type FlattenedValueTypesOf } from 'types/flattened_value_types_of'
-
-describe('FlattenedValueTypesOf', function () {
-  // note we only test a small example since most of the work is done in flatten
-  describe('record', function () {
-    const builder = record<typeof numberType, string>(numberType)
-    type V = FlattenedValueTypesOf<typeof builder>
-
-    let v: {
-      readonly $: Record<string, number>,
-      readonly [_: `$.${string}`]: number,
-    }
-    it('equals expected type', function () {
-      expectTypeOf(v).toEqualTypeOf<V>()
-    })
-  })
-})

package/types/value_type_of.ts

@@ -1,84 +0,0 @@
-import {
-  type IsFieldReadonly,
-} from '@strictly/base'
-import {
-  type ListTypeDef,
-  type LiteralTypeDef,
-  type ObjectTypeDef,
-  type RecordTypeDef,
-  type Type,
-  type TypeDef,
-  type UnionTypeDef,
-} from './definitions'
-
-export type ValueTypeOf<
-  T,
-  Extra = {},
-> = T extends Type ? InternalValueTypeOf<T['definition'], Extra> : never
-
-export type InternalValueTypeOf<
-  F extends TypeDef,
-  Extra,
-> = F extends LiteralTypeDef ? InternalValueTypeOfLiteral<F>
-  : F extends ListTypeDef ? InternalValueTypeOfList<F, Extra>
-  : F extends RecordTypeDef ? InternalValueTypeOfRecord<F, Extra>
-  : F extends ObjectTypeDef ? InternalValueTypeOfObject<F, Extra>
-  : F extends UnionTypeDef ? InternalValueTypeOfUnion<F, Extra>
-  : never
-
-type InternalValueTypeOfLiteral<F extends LiteralTypeDef> = F['valuePrototype'][number]
-
-type InternalValueTypeOfList<F extends ListTypeDef, Extra> = IsFieldReadonly<F, 'elements'> extends true
-  ? readonly InternalValueTypeOf<
-    F['elements'],
-    Extra
-  >[] & Extra
-  : InternalValueTypeOf<
-    F['elements'],
-    Extra
-  >[] & Extra
-
-type InternalValueTypeOfRecord<
-  F extends RecordTypeDef,
-  Extra,
-> = undefined extends F['valueTypeDef']
-  // partial
-  ? IsFieldReadonly<F, 'valueTypeDef'> extends true
-    // readonly
-    ? {
-      readonly [k in F['keyPrototype']]?: InternalValueTypeOf<F['valueTypeDef'], Extra>
-    }
-  : {
-    [k in F['keyPrototype']]?: InternalValueTypeOf<F['valueTypeDef'], Extra>
-  }
-  // complete
-  : IsFieldReadonly<F, 'valueTypeDef'> extends true
-  // readonly
-    ? {
-      readonly [k in F['keyPrototype']]: InternalValueTypeOf<F['valueTypeDef'], Extra>
-    }
-  : {
-    [k in F['keyPrototype']]: InternalValueTypeOf<F['valueTypeDef'], Extra>
-  }
-
-type InternalValueTypeOfObject<
-  F extends ObjectTypeDef,
-  Extra,
-> = F extends ObjectTypeDef<infer Fields> ? {
-    [K in keyof Fields]: InternalValueTypeOf<
-      Fields[K],
-      Extra
-    >
-  } & Extra
-  : never
-
-type InternalValueTypeOfUnion<
-  F extends UnionTypeDef,
-  Extra,
-> = F extends UnionTypeDef<infer D, infer U> ? D extends string ? {
-      [K in keyof U]: InternalValueTypeOf<U[K], Extra> & Readonly<Record<D, K>>
-    }[keyof U]
-  : {
-    [K in keyof U]: InternalValueTypeOf<U[K], Extra>
-  }[keyof U]
-  : never