@strictly/define 0.0.1

package/index.ts

@@ -0,0 +1,20 @@
+export * from './transformers/copies/copy'
+export * from './transformers/copies/mobx_copy'
+export * from './transformers/flatteners/flatten_accessors_of'
+export * from './transformers/flatteners/flatten_json_value_to_type_paths_of'
+export * from './transformers/flatteners/flatten_type_defs_of'
+export * from './transformers/flatteners/flatten_value_type_to'
+export * from './transformers/flatteners/json_path'
+export * from './transformers/flatteners/value_path_to_type_path'
+export * from './types/builders'
+export * from './types/definitions'
+export * from './types/flattened_accessors_of'
+export * from './types/flattened_type_defs_of'
+export * from './types/flattened_value_types_of'
+export * from './types/json_paths_of'
+export * from './types/mobx_value_type_of'
+export * from './types/readonly_type_def_of'
+export * from './types/strict_definitions'
+export * from './types/value_to_type_paths_of'
+export * from './types/value_type_of'
+export * from './types/value_types_of_discriminated_union'

package/package.exports.json

@@ -0,0 +1,18 @@
+{
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts"
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "dependencies": {
+    "@strictly/base": "*",
+    "mobx": "^6.13.5"
+  },
+  "devDependencies": {
+    "@strictly/support-vite": "*"
+  },
+  "license": "MIT",
+  "name": "@strictly/define",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "directory": "packages/define",
+    "type": "git",
+    "url": "git+https://github.com/madmaw/de.git"
+  },
+  "scripts": {
+    "build": "tsup",
+    "check-types": "tsc",
+    "clean": "del-cli dist",
+    "lint": "cross-env ESLINT_USE_FLAT_CONFIG=false eslint . --max-warnings=0",
+    "lint:fix": "cross-env ESLINT_USE_FLAT_CONFIG=false eslint . --fix",
+    "release:exports": "json -f package.json -f package.exports.json --merge > package.release.json",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "type": "module",
+  "version": "0.0.1",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts"
+}

package/transformers/copies/copy.ts

@@ -0,0 +1,18 @@
+import { type ReadonlyTypeDefOf } from 'types/readonly_type_def_of'
+import { type StrictType } from 'types/strict_definitions'
+import { type ValueTypeOf } from 'types/value_type_of'
+import {
+  type AnyValueType,
+  copyTo,
+} from './copy_to'
+
+function identity(v: AnyValueType): AnyValueType {
+  return v
+}
+
+export function copy<T extends StrictType>(
+  t: T,
+  proto: ValueTypeOf<ReadonlyTypeDefOf<T>>,
+): ValueTypeOf<T> {
+  return copyTo(t, proto, identity)
+}

package/transformers/copies/copy_to.ts

@@ -0,0 +1,226 @@
+import {
+  map,
+  reduce,
+  UnexpectedImplementationError,
+  UnreachableError,
+} from '@strictly/base'
+import {
+  type ObjectFieldKey,
+  type TypeDef,
+  TypeDefType,
+  type UnionKey,
+} from 'types/definitions'
+import { type ReadonlyTypeDefOf } from 'types/readonly_type_def_of'
+import {
+  type StrictListTypeDef,
+  type StrictLiteralTypeDef,
+  type StrictObjectTypeDef,
+  type StrictRecordTypeDef,
+  type StrictStructuredTypeDefFields,
+  type StrictType,
+  type StrictTypeDef,
+  type StrictUnionTypeDef,
+} from 'types/strict_definitions'
+import { type ValueTypeOf } from 'types/value_type_of'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type AnyValueType = any
+
+export type Copier<R> = (v: AnyValueType, t: StrictTypeDef) => R
+
+export function copyTo<
+  T extends StrictType,
+  R extends ValueTypeOf<ReadonlyTypeDefOf<T>>,
+>(
+  { definition }: T,
+  value: ValueTypeOf<ReadonlyTypeDefOf<T>>,
+  copier: Copier<R>,
+): R {
+  return internalCopyTo(
+    definition,
+    value,
+    copier,
+  )
+}
+
+/**
+ * Creates a copy of the supplied value
+ * @param def description of the object to create
+ * @param value the value to populate the object from
+ * @returns a copy of the supplied value
+ */
+function internalCopyTo<R>(
+  definition: TypeDef,
+  value: AnyValueType,
+  copier: Copier<R>,
+): R {
+  switch (definition.type) {
+    case TypeDefType.Literal:
+      return copyLiteral(
+        definition,
+        value,
+        copier,
+      )
+    case TypeDefType.List:
+      return copyList(
+        definition,
+        value,
+        copier,
+      )
+    case TypeDefType.Record:
+      return copyRecord(
+        definition,
+        value,
+        copier,
+      )
+    case TypeDefType.Object:
+      return copyObject(
+        definition,
+        value,
+        copier,
+      )
+    case TypeDefType.Union:
+      return copyUnion(
+        definition,
+        value,
+        copier,
+      )
+    default:
+      throw new UnreachableError(definition)
+  }
+}
+
+function copyLiteral<
+  R,
+>(
+  typeDef: StrictLiteralTypeDef,
+  value: ValueTypeOf<{ definition: StrictLiteralTypeDef }>,
+  copier: Copier<R>,
+): R {
+  // mutable and immutable literals should be the same type
+  return copier(value, typeDef)
+}
+
+function copyList<
+  R,
+>(
+  typeDef: StrictListTypeDef,
+  arr: AnyValueType[],
+  copier: Copier<R>,
+): R {
+  const {
+    elements,
+  } = typeDef
+  const list = arr.map(function (value) {
+    return internalCopyTo(elements, value, copier)
+  })
+  return copier(
+    list,
+    typeDef,
+  )
+}
+
+function copyRecord<
+  R,
+>(
+  typeDef: StrictRecordTypeDef,
+  value: AnyValueType,
+  copier: Copier<R>,
+): R {
+  const {
+    valueTypeDef,
+  } = typeDef
+  const record = map(
+    value,
+    function (_key, value) {
+      return internalCopyTo(valueTypeDef, value, copier)
+    },
+  )
+  return copier(
+    record,
+    typeDef,
+  )
+}
+
+function copyObjectFields<
+  R,
+  Extra extends Record<string, UnionKey>,
+>(
+  fields: StrictStructuredTypeDefFields,
+  value: Record<ObjectFieldKey, AnyValueType>,
+  copier: Copier<R>,
+  extra: Extra,
+): Record<ObjectFieldKey, AnyValueType> {
+  const record = reduce(fields, function (acc, key, field: TypeDef) {
+    const fieldValue = value[key]
+    acc[key] = fieldValue != null
+      ? internalCopyTo(field, fieldValue, copier)
+      : fieldValue
+    return acc
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  }, extra as Record<string | number | symbol, AnyValueType>)
+  return record
+}
+
+function copyObject<
+  R,
+>(
+  typeDef: StrictObjectTypeDef,
+  value: AnyValueType,
+  copier: Copier<R>,
+): R {
+  const {
+    fields,
+  } = typeDef
+  const record = copyObjectFields(fields, value, copier, {})
+  return copier(record, typeDef)
+}
+
+function copyUnion<
+  R,
+>(
+  typeDef: StrictUnionTypeDef,
+  value: AnyValueType,
+  copier: Copier<R>,
+): R {
+  const {
+    discriminator,
+    unions,
+  } = typeDef
+
+  // is it a discriminated union with a struct?
+  if (discriminator != null) {
+    const discriminatorValue = value[discriminator]
+    const discriminatingUnion = {
+      ...internalCopyTo(
+        unions[discriminatorValue],
+        value,
+        copier,
+      ),
+      [discriminator]: discriminatorValue,
+    }
+    return copier(discriminatingUnion, typeDef)
+  }
+
+  // is it a `<constant1> | <constant2> | X`? We can handle that
+  // a good example is when we `| null` something
+  const allTypeDefs = Object.values<TypeDef>(unions)
+  const variableTypeDefs = allTypeDefs.filter(function (typeDef: TypeDef) {
+    return typeDef.type !== TypeDefType.Literal || typeDef.valuePrototype == null
+  })
+  if (variableTypeDefs.length <= 1) {
+    // can handle up to one non-constant value
+    const targetTypeDef = allTypeDefs.find(function (typeDef) {
+      return typeDef.type === TypeDefType.Literal
+        && typeDef.valuePrototype != null
+        && typeDef.valuePrototype.indexOf(value) >= 0
+    }) || variableTypeDefs[0]
+    return internalCopyTo(targetTypeDef, value, copier)
+  }
+
+  // oh dear!
+  // this should have caused a type error already
+  throw new UnexpectedImplementationError(
+    'unions must be strict in order to be copied',
+  )
+}

package/transformers/copies/mobx_copy.ts

@@ -0,0 +1,81 @@
+import {
+  reduce,
+  UnreachableError,
+} from '@strictly/base'
+import {
+  type IObservableFactory,
+  makeObservable,
+  observable,
+} from 'mobx'
+import { getUnionTypeDef } from 'transformers/flatteners/flatten_value_type_to'
+import {
+  type ObjectFieldKey,
+  TypeDefType,
+} from 'types/definitions'
+import { type MobxValueTypeOf } from 'types/mobx_value_type_of'
+import { type ReadonlyTypeDefOf } from 'types/readonly_type_def_of'
+import {
+  type StrictType,
+  type StrictTypeDef,
+} from 'types/strict_definitions'
+import { type ValueTypeOf } from 'types/value_type_of'
+import {
+  type AnyValueType,
+  copyTo,
+} from './copy_to'
+
+function observeValue(
+  v: AnyValueType,
+  def: StrictTypeDef,
+): AnyValueType {
+  if (v == null) {
+    return v
+  }
+  switch (def.type) {
+    case TypeDefType.Literal:
+      return v
+    case TypeDefType.List:
+      // can't work out that an observable array is an array
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
+      return observable.array(v as any[], { deep: false }) as any
+    case TypeDefType.Record:
+      // observable observes all fields
+      return observable(
+        v,
+        {},
+        {
+          deep: false,
+        },
+      )
+    case TypeDefType.Object:
+      // `makeObservable` only observes the specified props
+      return makeObservable(
+        v,
+        reduce(
+          def.fields,
+          function (acc, k) {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            acc[k as ObjectFieldKey] = observable
+            return acc
+          },
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          {} as Record<ObjectFieldKey, IObservableFactory>,
+        ),
+        {
+          deep: false,
+        },
+      )
+    case TypeDefType.Union:
+      // delegate to the underlying value
+      return observeValue(v, getUnionTypeDef(def, v))
+    default:
+      throw new UnreachableError(def)
+  }
+}
+
+export function mobxCopy<T extends StrictType>(
+  t: T,
+  proto: ValueTypeOf<ReadonlyTypeDefOf<T>>,
+): MobxValueTypeOf<T> {
+  return copyTo(t, proto, observeValue)
+}

package/transformers/copies/specs/copy_to.tests.ts

@@ -0,0 +1,143 @@
+import {
+  type AnyValueType,
+  copyTo,
+} from 'transformers/copies/copy_to'
+import {
+  booleanType,
+  list,
+  literal,
+  numberType,
+  object,
+  record,
+  stringType,
+  union,
+} from 'types/builders'
+import { TypeDefType } from 'types/definitions'
+import { type StrictTypeDef } from 'types/strict_definitions'
+
+describe('copyTo', function () {
+  function toString(v: AnyValueType, t: StrictTypeDef) {
+    if (t.type === TypeDefType.Literal) {
+      return JSON.stringify(v)
+    } else {
+      return v
+    }
+  }
+
+  describe('literal', function () {
+    const type = literal<1>()
+    it('copies', function () {
+      const c = copyTo(type, 1, toString)
+      expect(c).toEqual('1')
+    })
+  })
+
+  describe('list', function () {
+    const typeDef = list(literal<number>())
+    it('copies', function () {
+      const c = copyTo(
+        typeDef,
+        [
+          1,
+          2,
+          3,
+        ],
+        toString,
+      )
+      expect(c).toEqual([
+        '1',
+        '2',
+        '3',
+      ])
+    })
+  })
+
+  describe('record', function () {
+    const typeDef = record<typeof numberType, 'a' | 'b'>(numberType)
+    it('copies', function () {
+      const c = copyTo(
+        typeDef,
+        {
+          a: 1,
+          b: 2,
+        },
+        toString,
+      )
+      expect(c).toEqual({
+        a: '1',
+        b: '2',
+      })
+    })
+  })
+
+  describe('object', function () {
+    const typeDef = object()
+      .set('a', numberType)
+      .set('b', booleanType)
+      .set('c', stringType)
+    it('copies', function () {
+      const c = copyTo(
+        typeDef,
+        {
+          a: 1,
+          b: true,
+          c: 'a',
+        },
+        toString,
+      )
+      expect(c).toEqual({
+        a: '1',
+        b: 'true',
+        c: '"a"',
+      })
+    })
+  })
+
+  describe('union', function () {
+    describe('non-discriminated', function () {
+      const typeDef = union()
+        .add('0', list(numberType))
+        .add('1', literal(['b']))
+        .add('2', literal([false]))
+      it('copies string literal', function () {
+        const c = copyTo(
+          typeDef,
+          'b',
+          toString,
+        )
+        expect(c).toEqual('"b"')
+      })
+
+      it('copies boolean literal', function () {
+        const c = copyTo(
+          typeDef,
+          false,
+          toString,
+        )
+        expect(c).toEqual('false')
+      })
+    })
+
+    describe('discriminated', function () {
+      const typeDef = union('d')
+        .add('a', object().set('x', numberType))
+        .add('b', object().set('y', booleanType))
+
+      it('copies', function () {
+        const c = copyTo(
+          typeDef,
+          {
+            d: 'a',
+            x: 1,
+          },
+          toString,
+        )
+
+        expect(c).toEqual({
+          d: 'a',
+          x: '1',
+        })
+      })
+    })
+  })
+})

package/transformers/copies/specs/mobx_copy.tests.ts

@@ -0,0 +1,26 @@
+import { mobxCopy } from 'transformers/copies/mobx_copy'
+import {
+  numberType,
+  object,
+} from 'types/builders'
+import { type ValueTypeOf } from 'types/value_type_of'
+
+describe('mobxCopy', function () {
+  describe('object', function () {
+    describe('optional field', function () {
+      const type = object().setOptional('n', numberType)
+      type T = ValueTypeOf<typeof type>
+      it('copies unpopulated', function () {
+        const v: T = {}
+        const c = mobxCopy(type, v)
+        expect(c).toEqual(v)
+      })
+
+      it('copies populated', function () {
+        const v: T = { n: 1 }
+        const c = mobxCopy(type, v)
+        expect(c).toEqual(v)
+      })
+    })
+  })
+})

package/transformers/flatteners/flatten_accessors_of.ts

@@ -0,0 +1,43 @@
+import {
+  type Type,
+  type TypeDef,
+} from 'types/definitions'
+import {
+  type Accessor,
+  type FlattenedAccessorsOf,
+} from 'types/flattened_accessors_of'
+import { type ValueTypeOf } from 'types/value_type_of'
+import {
+  type AnyValueType,
+  flattenValueTypeTo,
+  type Setter,
+} from './flatten_value_type_to'
+
+function mapAccessor(
+  _t: TypeDef,
+  value: AnyValueType,
+  set: Setter<AnyValueType>,
+): Accessor<AnyValueType> {
+  return {
+    value,
+    set,
+  }
+}
+
+export function flattenAccessorsOf<
+  T extends Type,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  R extends Readonly<Record<string, Accessor<any>>> = FlattenedAccessorsOf<T>,
+>(
+  t: T,
+  value: ValueTypeOf<T>,
+  setValue: Setter<ValueTypeOf<T>>,
+): R {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return flattenValueTypeTo<T, Accessor<any>, R>(
+    t,
+    value,
+    setValue,
+    mapAccessor,
+  )
+}

package/transformers/flatteners/flatten_json_value_to_type_paths_of.ts

@@ -0,0 +1,39 @@
+import {
+  type Type,
+  type TypeDef,
+} from 'types/definitions'
+import { type ValueTypeOf } from 'types/value_type_of'
+import {
+  type AnyValueType,
+  flattenValueTypeTo,
+  type Setter,
+} from './flatten_value_type_to'
+
+function mapTypePaths(
+  _t: TypeDef,
+  _value: AnyValueType,
+  _set: Setter<AnyValueType>,
+  typePath: string,
+) {
+  return typePath
+}
+
+export function flattenJsonValueToTypePathsOf<
+  T extends Type,
+  R extends Record<string, string | number | symbol>,
+>(
+  t: T,
+  value: ValueTypeOf<T>,
+  // TODO
+  // : FlattenedJsonValueToTypePathsOf<T>
+): R {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return flattenValueTypeTo(
+    t,
+    value,
+    function () {
+      // do nothing
+    },
+    mapTypePaths,
+  ) as R
+}