@strictly/define 0.0.26 → 0.0.28

package/.out/transformers/flatteners/flatten_accessors_of_type.d.ts

@@ -2,4 +2,4 @@ import { type Type } from 'types/definitions';
 import { type Accessor, type FlattenedAccessorsOfType } from 'types/flattened_accessors_of_type';
 import { type ValueOfType } from 'types/value_of_type';
 import { type Setter } from './flatten_value_to';
-export declare function flattenAccessorsOfType<T extends Type, R extends Readonly<Record<string, Accessor<any>>> = FlattenedAccessorsOfType<T>>(t: T, value: ValueOfType<T>, setValue: Setter<ValueOfType<T>>): R;
+export declare function flattenAccessorsOfType<T extends Type, R extends Readonly<Record<string, Accessor<any>>> = FlattenedAccessorsOfType<T>>(t: T, value: ValueOfType<T>, setValue: Setter<ValueOfType<T>>, listIndicesToKeys?: Record<string, number[]>): R;

package/.out/transformers/flatteners/flatten_accessors_of_type.js

@@ -5,7 +5,7 @@ function mapAccessor(_t, value, set) {
         set,
     };
 }
-export function flattenAccessorsOfType(t, value, setValue) {
+export function flattenAccessorsOfType(t, value, setValue, listIndicesToKeys) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return flattenValueTo(t, value, setValue, mapAccessor);
+    return flattenValueTo(t, value, setValue, mapAccessor, listIndicesToKeys);
 }

package/.out/transformers/flatteners/flatten_json_value_to_type_paths_of.d.ts

@@ -1,3 +1,3 @@
 import { type Type } from 'types/definitions';
 import { type ValueOfType } from 'types/value_of_type';
-export declare function flattenJsonValueToTypePathsOf<T extends Type, R extends Record<string, string | number | symbol>>(t: T, value: ValueOfType<T>): R;
+export declare function flattenJsonValueToTypePathsOf<T extends Type, R extends Record<string, string | number | symbol>>(t: T, value: ValueOfType<T>, listIndicesToKeys?: Record<string, number[]>): R;

package/.out/transformers/flatteners/flatten_json_value_to_type_paths_of.js

@@ -2,9 +2,12 @@ import { flattenValueTo, } from './flatten_value_to';
 function mapTypePaths(_t, _value, _set, typePath) {
     return typePath;
 }
-export function flattenJsonValueToTypePathsOf(t, value) {
+export function flattenJsonValueToTypePathsOf(t, value, 
+// TODO
+// : FlattenedJsonValueToTypePathsOf<T>
+listIndicesToKeys) {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return flattenValueTo(t, value, function () {
         // do nothing
-    }, mapTypePaths);
+    }, mapTypePaths, listIndicesToKeys);
 }

package/.out/transformers/flatteners/flatten_validation_errors_of_type.d.ts

@@ -18,5 +18,5 @@ export type ValuePathsToValidatorsOf<TypePathsToAdapters extends Partial<Readonl
 export type FlattenedValidatorsOfType<T extends Type, Flattened extends Readonly<Record<string, Type>> = FlattenedTypesOfType<T, '*'>> = {
     [K in keyof Flattened]: Validator;
 };
-export declare function flattenValidationErrorsOfType<T extends Type, ValueToTypePaths extends Readonly<Record<string, string>>, TypePathsToValidators extends FlattenedTypePathsToValidatorsOf<FlattenedValuesOfType<T, '*'>, ValueOfType<ReadonlyTypeOfType<T>>>, ValuePathsToValidators extends ValuePathsToValidatorsOf<TypePathsToValidators, ValueToTypePaths> = ValuePathsToValidatorsOf<TypePathsToValidators, ValueToTypePaths>>(type: T, value: ValueOfType<T>, validators: TypePathsToValidators): ErrorsOfFlattenedValidators<ValuePathsToValidators>;
+export declare function flattenValidationErrorsOfType<T extends Type, ValueToTypePaths extends Readonly<Record<string, string>>, TypePathsToValidators extends FlattenedTypePathsToValidatorsOf<FlattenedValuesOfType<T, '*'>, ValueOfType<ReadonlyTypeOfType<T>>>, ValuePathsToValidators extends ValuePathsToValidatorsOf<TypePathsToValidators, ValueToTypePaths> = ValuePathsToValidatorsOf<TypePathsToValidators, ValueToTypePaths>>(type: T, value: ValueOfType<T>, validators: TypePathsToValidators, listIndicesToKeys?: Record<string, number[]>): ErrorsOfFlattenedValidators<ValuePathsToValidators>;
 export {};

package/.out/transformers/flatteners/flatten_validation_errors_of_type.js

@@ -1,10 +1,10 @@
 import { flattenValueTo, } from 'transformers/flatteners/flatten_value_to';
 import { validate, } from 'validation/validator';
-export function flattenValidationErrorsOfType(type, value, validators) {
+export function flattenValidationErrorsOfType(type, value, validators, listIndicesToKeys) {
     return flattenValueTo(type, value, () => { }, function (_t, v, _setter, typePath, valuePath) {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         const validator = validators[typePath];
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         return validator != null ? validate(validator, v, valuePath, value) : null;
-    });
+    }, listIndicesToKeys);
 }

package/.out/transformers/flatteners/flatten_value_to.d.ts

@@ -5,7 +5,7 @@ import { type ValueOfType } from 'types/value_of_type';
 export type AnyValueType = any;
 export type Setter<V> = (v: V) => void;
 export type Mapper<R> = (t: StrictTypeDef, v: AnyValueType, setter: Setter<AnyValueType>, typePath: string, valuePath: string) => R;
-export declare function flattenValueTo<T extends StrictType, M, R extends Readonly<Record<string, M>>>({ definition }: T, v: ValueOfType<T>, setter: Setter<ValueOfType<T>>, mapper: Mapper<M>): R;
+export declare function flattenValueTo<T extends StrictType, M, R extends Readonly<Record<string, M>>>({ definition }: T, v: ValueOfType<T>, setter: Setter<ValueOfType<T>>, mapper: Mapper<M>, listIndicesToKeys?: Record<string, number[]>): R;
 export declare function getUnionTypeDef<T extends UnionTypeDef>(typeDef: T, v: ValueOfType<ReadonlyTypeOfType<{
     definition: T;
 }>>): any;

package/.out/transformers/flatteners/flatten_value_to.js

@@ -1,66 +1,81 @@
 import { reduce, UnreachableError, } from '@strictly/base';
 import { TypeDefType, } from 'types/definitions';
 import { jsonPath } from './json_path';
-export function flattenValueTo({ definition }, v, setter, mapper) {
+export function flattenValueTo({ definition }, v, setter, mapper, 
+// used to maintain keys when changing lists, note that the format for a list of three elements is
+// [key1, key2, key3, nextKey]
+// the final value always contains the next key
+listIndicesToKeys = {}) {
     const r = {};
-    internalFlattenValue('$', '$', definition, v, setter, mapper, r);
+    internalFlattenValue('$', '$', definition, v, setter, mapper, r, listIndicesToKeys);
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return r;
 }
-function internalFlattenValue(valuePath, typePath, typeDef, v, setter, mapper, r) {
+function internalFlattenValue(valuePath, typePath, typeDef, v, setter, mapper, r, listIndicesToKeys) {
     r[valuePath] = mapper(typeDef, v, setter, typePath, valuePath);
     // assume undefined means the field is optional and not populated
     // TODO: actually capture if field is optional in typedef (or in builder for creating validator)
     if (v !== undefined) {
-        return internalFlattenValueChildren(valuePath, typePath, typeDef, v, mapper, r);
+        return internalFlattenValueChildren(valuePath, typePath, typeDef, v, mapper, r, listIndicesToKeys);
     }
     return r;
 }
-function internalFlattenValueChildren(valuePath, typePath, typeDef, v, mapper, r) {
+function internalFlattenValueChildren(valuePath, typePath, typeDef, v, mapper, r, listIndicesToKeys) {
     switch (typeDef.type) {
         case TypeDefType.Literal:
             // no children
             return r;
         case TypeDefType.List:
-            return internalFlattenListChildren(valuePath, typePath, typeDef, v, mapper, r);
+            return internalFlattenListChildren(valuePath, typePath, typeDef, v, mapper, r, listIndicesToKeys);
         case TypeDefType.Record:
-            return internalFlattenRecordChildren(valuePath, typePath, typeDef, v, mapper, r);
+            return internalFlattenRecordChildren(valuePath, typePath, typeDef, v, mapper, r, listIndicesToKeys);
         case TypeDefType.Object:
-            return internalFlattenObjectChildren(valuePath, typePath, typeDef, v, mapper, r);
+            return internalFlattenObjectChildren(valuePath, typePath, typeDef, v, mapper, r, listIndicesToKeys);
         case TypeDefType.Union:
-            return internalFlattenUnionChildren(valuePath, typePath, typeDef, v, mapper, r);
+            return internalFlattenUnionChildren(valuePath, typePath, typeDef, v, mapper, r, listIndicesToKeys);
         default:
             throw new UnreachableError(typeDef);
     }
 }
-function internalFlattenListChildren(valuePath, typePath, { elements }, v, mapper, r) {
+function internalFlattenListChildren(valuePath, typePath, { elements }, v, mapper, r, listIndicesToKeys) {
+    let indicesToKeys = listIndicesToKeys[valuePath];
+    if (indicesToKeys == null) {
+        indicesToKeys = [0];
+        listIndicesToKeys[valuePath] = indicesToKeys;
+    }
     const newTypePath = jsonPath(typePath, '*');
-    return v.reduce(function (r, e, i) {
-        return internalFlattenValue(jsonPath(valuePath, i), newTypePath, elements, e, (e) => {
-            v[i] = e;
-        }, mapper, r);
+    return v.reduce(function (r, e, index) {
+        const key = indicesToKeys[index];
+        // we have consumed the next id passively
+        if (index === indicesToKeys.length - 1) {
+            // we have consumed the next key, so we need to add a new one
+            indicesToKeys.push(key + 1);
+        }
+        return internalFlattenValue(jsonPath(valuePath, key), newTypePath, elements, e, (e) => {
+            v[index] = e;
+        }, mapper, r, listIndicesToKeys);
     }, r);
 }
-function internalFlattenRecordChildren(valuePath, typePath, { valueTypeDef }, v, mapper, r) {
+function internalFlattenRecordChildren(valuePath, typePath, { valueTypeDef }, v, mapper, r, listIndicesToKeys) {
     const newTypePath = jsonPath(typePath, '*');
     return reduce(v, function (r, k, value) {
         return internalFlattenValue(jsonPath(valuePath, k), newTypePath, valueTypeDef, value, (value) => {
             v[k] = value;
-        }, mapper, r);
+        }, mapper, r, listIndicesToKeys);
     }, r);
 }
-function internalFlattenObjectChildren(valuePath, typePath, { fields }, v, mapper, r) {
+function internalFlattenObjectChildren(valuePath, typePath, { fields }, v, mapper, r, listIndicesToKeys) {
     return reduce(fields, function (r, k, fieldTypeDef) {
         const fieldValue = v[k];
         return internalFlattenValue(jsonPath(valuePath, k), jsonPath(typePath, k), fieldTypeDef, fieldValue, (value) => {
             v[k] = value;
-        }, mapper, r);
+        }, mapper, r, listIndicesToKeys);
     }, r);
 }
-function internalFlattenUnionChildren(valuePath, typePath, typeDef, v, mapper, r) {
+function internalFlattenUnionChildren(valuePath, typePath, typeDef, v, mapper, r, listIndicesToKeys) {
     const childTypeDef = getUnionTypeDef(typeDef, v);
     const qualifier = typeDef.discriminator != null ? `:${v[typeDef.discriminator]}` : '';
-    return internalFlattenValueChildren(`${valuePath}${qualifier}`, `${typePath}${qualifier}`, childTypeDef, v, mapper, r);
+    return internalFlattenValueChildren(`${valuePath}${qualifier}`, `${typePath}${qualifier}`, childTypeDef, v, mapper, r, listIndicesToKeys);
 }
 export function getUnionTypeDef(typeDef, v) {
     if (typeDef.discriminator == null) {

package/.out/transformers/flatteners/flatten_values_of_type.d.ts

@@ -1,3 +1,3 @@
 import { type Type } from 'types/definitions';
 import { type ValueOfType } from 'types/value_of_type';
-export declare function flattenValuesOfType<T extends Type>(typeDef: Type, value: ValueOfType<T>): Record<string, any>;
+export declare function flattenValuesOfType<T extends Type>(typeDef: Type, value: ValueOfType<T>, listIndicesToKeys?: Record<string, number[]>): Record<string, any>;

package/.out/transformers/flatteners/flatten_values_of_type.js

@@ -2,6 +2,6 @@ import { flattenValueTo, } from './flatten_value_to';
 function mapper(_t, v) {
     return v;
 }
-export function flattenValuesOfType(typeDef, value) {
-    return flattenValueTo(typeDef, value, () => { }, mapper);
+export function flattenValuesOfType(typeDef, value, listIndicesToKeys) {
+    return flattenValueTo(typeDef, value, () => { }, mapper, listIndicesToKeys);
 }