@strictly/define 0.0.21 → 0.0.23

package/.out/transformers/flatteners/flatten_type_to.js

@@ -44,6 +44,6 @@ function internalFlattenObjectTypeDefChildren(path, qualifier, { fields }, r) {
 }
 function internalFlattenUnionTypeDefChildren(path, qualifier, { discriminator, unions, }, r) {
     return reduce(unions, function (acc, key, typeDef) {
-        return internalFlattenTypeDefChildren(path, discriminator != null ? `${qualifier}${key}:` : qualifier, typeDef, acc);
+        return internalFlattenTypeDefChildren(discriminator != null ? `${path}:${qualifier}` : path, key, typeDef, acc);
     }, r);
 }

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

@@ -12,11 +12,11 @@ function internalFlattenValue(valuePath, typePath, typeDef, v, setter, mapper, r
     // 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);
     }
     return r;
 }
-function internalFlattenValueChildren(valuePath, typePath, qualifier, typeDef, v, mapper, r) {
+function internalFlattenValueChildren(valuePath, typePath, typeDef, v, mapper, r) {
     switch (typeDef.type) {
         case TypeDefType.Literal:
             // no children
@@ -26,9 +26,9 @@ function internalFlattenValueChildren(valuePath, typePath, qualifier, typeDef, v
         case TypeDefType.Record:
             return internalFlattenRecordChildren(valuePath, typePath, typeDef, v, mapper, r);
         case TypeDefType.Object:
-            return internalFlattenObjectChildren(valuePath, typePath, qualifier, typeDef, v, mapper, r);
+            return internalFlattenObjectChildren(valuePath, typePath, typeDef, v, mapper, r);
         case TypeDefType.Union:
-            return internalFlattenUnionChildren(valuePath, typePath, qualifier, typeDef, v, mapper, r);
+            return internalFlattenUnionChildren(valuePath, typePath, typeDef, v, mapper, r);
         default:
             throw new UnreachableError(typeDef);
     }
@@ -49,18 +49,18 @@ function internalFlattenRecordChildren(valuePath, typePath, { valueTypeDef }, v,
         }, mapper, r);
     }, r);
 }
-function internalFlattenObjectChildren(valuePath, typePath, qualifier, { fields }, v, mapper, r) {
+function internalFlattenObjectChildren(valuePath, typePath, { fields }, v, mapper, r) {
     return reduce(fields, function (r, k, fieldTypeDef) {
         const fieldValue = v[k];
-        return internalFlattenValue(jsonPath(valuePath, k, qualifier), jsonPath(typePath, k, qualifier), fieldTypeDef, fieldValue, (value) => {
+        return internalFlattenValue(jsonPath(valuePath, k), jsonPath(typePath, k), fieldTypeDef, fieldValue, (value) => {
             v[k] = value;
         }, mapper, r);
     }, r);
 }
-function internalFlattenUnionChildren(valuePath, typePath, qualifier, typeDef, v, mapper, r) {
+function internalFlattenUnionChildren(valuePath, typePath, typeDef, v, mapper, r) {
     const childTypeDef = getUnionTypeDef(typeDef, v);
-    const newQualifier = typeDef.discriminator != null ? `${qualifier}${v[typeDef.discriminator]}:` : qualifier;
-    return internalFlattenValueChildren(valuePath, typePath, newQualifier, childTypeDef, v, mapper, r);
+    const qualifier = typeDef.discriminator != null ? `:${v[typeDef.discriminator]}` : '';
+    return internalFlattenValueChildren(`${valuePath}${qualifier}`, `${typePath}${qualifier}`, childTypeDef, v, mapper, r);
 }
 export function getUnionTypeDef(typeDef, v) {
     if (typeDef.discriminator == null) {

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

@@ -1,6 +1,6 @@
 import { type StringConcatOf } from '@strictly/base';
 export declare function jsonPath<Prefix extends string, Segment extends number | string>(prefix: Prefix, segment: Segment): `${Prefix}.${Segment}`;
-export declare function jsonPath<Prefix extends string, Segment extends number | string, Qualifier extends string>(prefix: Prefix, segment: Segment, qualifier: Qualifier): `${Prefix}.${Qualifier}${Segment}`;
+export declare function jsonPath<Prefix extends string, Segment extends number | string, Qualifier extends string>(prefix: Prefix, segment: Segment, qualifier: Qualifier): `${Prefix}${Qualifier}.${Segment}`;
 export declare function jsonPathPop<Path extends string>(path: Path): [string, string] | null;
 export declare function jsonPathPrefix<Prefix extends string, Path extends string>(prefix: Prefix, path: Path): Path extends StringConcatOf<'$', infer ToMount> ? `${Prefix}${ToMount}` : never;
 export declare function jsonPathUnprefix<Prefix extends string, Path extends string>(prefix: Prefix, path: Path): Path extends StringConcatOf<Prefix, infer ToUnmount> ? `$${ToUnmount}` : never;

package/.out/transformers/flatteners/json_path.js

@@ -1,8 +1,8 @@
 import { assertEqual, assertState, } from '@strictly/base';
 export function jsonPath(prefix, segment, qualifier) {
-    const s = `.${qualifier !== null && qualifier !== void 0 ? qualifier : ''}${segment}`;
+    const s = `.${segment}`;
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return `${prefix}${s}`;
+    return `${prefix}${qualifier !== null && qualifier !== void 0 ? qualifier : ''}${s}`;
 }
 // TODO type safety
 export function jsonPathPop(path) {

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

@@ -85,8 +85,8 @@ describe('flattenJsonValueToTypePathsOf', function () {
             it('equals expected value', function () {
                 expect(flattened).toEqual({
                     $: '$',
-                    '$.x:a': '$.x:a',
-                    '$.x:b': '$.x:b',
+                    '$:x.a': '$:x.a',
+                    '$:x.b': '$:x.b',
                 });
             });
         });

package/.out/transformers/flatteners/specs/flatten_type_to.tests.js

@@ -100,8 +100,8 @@ describe('flattenTypeDefTo', function () {
             it('equals expected type', function () {
                 expect(flattened).toEqual({
                     $: TypeDefType.Union,
-                    '$.a:a': TypeDefType.Literal,
-                    '$.b:b': TypeDefType.Literal,
+                    '$:a.a': TypeDefType.Literal,
+                    '$:b.b': TypeDefType.Literal,
                 });
             });
             it('calls the mapper function', function () {

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

@@ -209,7 +209,7 @@ describe('flattenValueTo', function () {
                 it('equals expected type', function () {
                     expect(flattened).toEqual({
                         $: '{"d":"1","a":2}',
-                        ['$.1:a']: '2',
+                        ['$:1.a']: '2',
                     });
                 });
             });
@@ -227,7 +227,7 @@ describe('flattenValueTo', function () {
                     expect(setter).toHaveBeenCalledWith(value);
                 });
                 it('sets an internal value', function () {
-                    flattened['$.1:a'](1);
+                    flattened['$:1.a'](1);
                     expect(u).toEqual({
                         d: '1',
                         a: 1,

package/.out/transformers/flatteners/specs/json_paths.tests.js

@@ -20,12 +20,12 @@ describe('json_paths', () => {
             });
         });
         describe('qualified', () => {
-            const path = jsonPath('$', 'x', 'y:');
+            const path = jsonPath('$', 'x', ':y');
             it('has the expected type', () => {
                 expectTypeOf(path).toEqualTypeOf();
             });
             it('has the expected value', () => {
-                expect(path).toEqual('$.y:x');
+                expect(path).toEqual('$:y.x');
             });
         });
     });

package/.out/transformers/flatteners/specs/value_path_to_type_path.tests.js

@@ -131,20 +131,20 @@ describe('valuePathToTypePath', function () {
                     '$',
                 ],
                 [
-                    '$.x:a',
-                    '$.x:a',
+                    '$:x.a',
+                    '$:x.a',
                 ],
                 [
-                    '$.x:b',
-                    '$.x:b',
+                    '$:x.b',
+                    '$:x.b',
                 ],
                 [
-                    '$.y:b',
-                    '$.y:b',
+                    '$:y.b',
+                    '$:y.b',
                 ],
                 [
-                    '$.y:c',
-                    '$.y:c',
+                    '$:y.c',
+                    '$:y.c',
                 ],
             ])('it maps %s', function (from, to) {
                 const typePath = valuePathToTypePath(typeDef, from);
@@ -164,6 +164,80 @@ describe('valuePathToTypePath', function () {
                     expectTypeOf(fakeTypePath).toEqualTypeOf();
                 });
             });
+            describe('nested discriminated', () => {
+                const nestedTypeDef = object().field('o', typeDef);
+                describe.each([
+                    [
+                        '$',
+                        '$',
+                    ],
+                    [
+                        '$.o',
+                        '$.o',
+                    ],
+                    [
+                        '$.o:x.a',
+                        '$.o:x.a',
+                    ],
+                    [
+                        '$.o:x.b',
+                        '$.o:x.b',
+                    ],
+                    [
+                        '$.o:y.b',
+                        '$.o:y.b',
+                    ],
+                    [
+                        '$.o:y.c',
+                        '$.o:y.c',
+                    ],
+                ])('it maps %s', function (from, to) {
+                    const typePath = valuePathToTypePath(nestedTypeDef, from);
+                    it('maps a value path to the expected type path', function () {
+                        expect(typePath).toEqual(to);
+                    });
+                    it('has expected type', function () {
+                        expectTypeOf(typePath).toEqualTypeOf(to);
+                    });
+                });
+            });
+            describe('list discriminated', () => {
+                const listTypeDef = list(typeDef);
+                describe.each([
+                    [
+                        '$',
+                        '$',
+                    ],
+                    [
+                        '$.0',
+                        '$.*',
+                    ],
+                    [
+                        '$.0:x.a',
+                        '$.*:x.a',
+                    ],
+                    [
+                        '$.0:x.b',
+                        '$.*:x.b',
+                    ],
+                    [
+                        '$.99:y.b',
+                        '$.*:y.b',
+                    ],
+                    [
+                        '$.1:y.c',
+                        '$.*:y.c',
+                    ],
+                ])('it maps %s', function (from, to) {
+                    const typePath = valuePathToTypePath(listTypeDef, from);
+                    it('maps a value path to the expected type path', function () {
+                        expect(typePath).toEqual(to);
+                    });
+                    it('has expected type', function () {
+                        expectTypeOf(typePath).toEqualTypeOf(to);
+                    });
+                });
+            });
         });
     });
 });

package/.out/transformers/flatteners/value_path_to_type_path.js

@@ -3,19 +3,23 @@ import { TypeDefType, } from 'types/definitions';
 export function valuePathToTypePath({ definition: typeDef }, valuePath, allowMissingPaths = false) {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const valueSteps = valuePath.split(/\.|\[/g);
-    assertEqual(valueSteps[0], '$');
-    const typeSteps = internalJsonValuePathToTypePath(typeDef, valueSteps.slice(1), allowMissingPaths, 
+    const parts = valueSteps[0].split(':');
+    const [first, ...qualifiers] = parts;
+    assertEqual(first, '$');
+    const typeSteps = internalJsonValuePathToTypePath(typeDef, qualifiers, valueSteps.slice(1), allowMissingPaths, 
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     valuePath);
-    typeSteps.unshift('$');
+    typeSteps.unshift(valueSteps[0]);
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return typeSteps.join('.');
 }
-function internalJsonValuePathToTypePath(typeDef, valueSteps, allowMissingPaths, originalValuePath) {
+function internalJsonValuePathToTypePath(typeDef, qualifiers, valueSteps, allowMissingPaths, originalValuePath) {
     if (valueSteps.length === 0) {
         return [];
     }
-    const [valueStep, ...remainingValueSteps] = valueSteps;
+    const [nextValueStepAndQualifiersString, ...remainingValueSteps] = valueSteps;
+    const nextValueStepAndQualifiers = nextValueStepAndQualifiersString.split(':');
+    const [valueStep, ...nextQualifiers] = nextValueStepAndQualifiers;
     switch (typeDef.type) {
         case TypeDefType.Literal:
             if (allowMissingPaths) {
@@ -23,18 +27,24 @@ function internalJsonValuePathToTypePath(typeDef, valueSteps, allowMissingPaths,
                 return valueSteps;
             }
             else {
-                throw new PreconditionFailedError('literal should terminate path {} ({})', originalValuePath, valueStep);
+                throw new PreconditionFailedError('literal should terminate path {} ({})', originalValuePath, nextValueStepAndQualifiersString);
             }
         case TypeDefType.List:
             // TODO assert format of current step
             return [
-                '*',
-                ...internalJsonValuePathToTypePath(typeDef.elements, remainingValueSteps, allowMissingPaths, originalValuePath),
+                [
+                    '*',
+                    ...nextQualifiers,
+                ].join(':'),
+                ...internalJsonValuePathToTypePath(typeDef.elements, nextQualifiers, remainingValueSteps, allowMissingPaths, originalValuePath),
             ];
         case TypeDefType.Record:
             return [
-                '*',
-                ...internalJsonValuePathToTypePath(typeDef.valueTypeDef, remainingValueSteps, allowMissingPaths, originalValuePath),
+                [
+                    '*',
+                    ...nextQualifiers,
+                ].join(':'),
+                ...internalJsonValuePathToTypePath(typeDef.valueTypeDef, nextQualifiers, remainingValueSteps, allowMissingPaths, originalValuePath),
             ];
         case TypeDefType.Object:
             if (allowMissingPaths) {
@@ -47,8 +57,8 @@ function internalJsonValuePathToTypePath(typeDef, valueSteps, allowMissingPaths,
                 assertExists(typeDef.fields[valueStep], 'missing field in {} ({})', originalValuePath, valueStep);
             }
             return [
-                valueStep,
-                ...internalJsonValuePathToTypePath(typeDef.fields[valueStep], remainingValueSteps, allowMissingPaths, originalValuePath),
+                nextValueStepAndQualifiersString,
+                ...internalJsonValuePathToTypePath(typeDef.fields[valueStep], nextQualifiers, remainingValueSteps, allowMissingPaths, originalValuePath),
             ];
         case TypeDefType.Union:
             if (typeDef.discriminator == null) {
@@ -61,7 +71,7 @@ function internalJsonValuePathToTypePath(typeDef, valueSteps, allowMissingPaths,
                         return acc;
                     }, null);
                     assertExists(union, 'expected a complex union {}', originalValuePath);
-                    return internalJsonValuePathToTypePath(union, valueSteps, allowMissingPaths, originalValuePath);
+                    return internalJsonValuePathToTypePath(union, nextQualifiers, valueSteps, allowMissingPaths, originalValuePath);
                 }
                 else {
                     // doesn't really matter
@@ -69,8 +79,7 @@ function internalJsonValuePathToTypePath(typeDef, valueSteps, allowMissingPaths,
                 }
             }
             else {
-                const qualifierIndex = valueStep.indexOf(':');
-                if (qualifierIndex < 0) {
+                if (qualifiers.length === 0) {
                     if (allowMissingPaths) {
                         return valueSteps;
                     }
@@ -78,17 +87,9 @@ function internalJsonValuePathToTypePath(typeDef, valueSteps, allowMissingPaths,
                         throw new PreconditionFailedError('mismatched qualifiers in {} (at {})', originalValuePath, valueStep);
                     }
                 }
-                const qualifier = valueStep.substring(0, qualifierIndex);
-                const remainder = valueStep.substring(qualifierIndex + 1);
+                const [qualifier, ...remainingQualifiers] = qualifiers;
                 const union = assertExistsAndReturn(typeDef.unions[qualifier], 'missing union {}', qualifier);
-                const [typeStep, ...remainingTypeSteps] = internalJsonValuePathToTypePath(union, [
-                    remainder,
-                    ...remainingValueSteps,
-                ], allowMissingPaths, originalValuePath);
-                return [
-                    `${qualifier}:${typeStep}`,
-                    ...remainingTypeSteps,
-                ];
+                return internalJsonValuePathToTypePath(union, remainingQualifiers, valueSteps, allowMissingPaths, originalValuePath);
             }
         default:
             throw new UnreachableError(typeDef);