@strictly/define 0.0.1

package/.eslintrc.cjs

@@ -0,0 +1,31 @@
+/* eslint-env node */
+/** @type {import('@types/eslint').Linter.Config} */
+module.exports = {
+  root: true,
+  extends: ['../../.eslintrc.cjs'],
+  parserOptions: {
+    project: [
+      'tsconfig.json',
+      'tsconfig.build.json',
+    ],
+    tsconfigRootDir: __dirname,
+    sourceType: 'module',
+    ecmaVersion: '2015',
+  },
+  rules: {
+    'import/no-extraneous-dependencies': [
+      'warn',
+      {
+        packageDir: [
+          '.',
+          '../..',
+        ],
+      },
+    ],
+    // the no-unsafe rules are not particularly compatible with the type definitions
+    '@typescript-eslint/no-unsafe-argument': 'off',
+    '@typescript-eslint/no-unsafe-call': 'off',
+    '@typescript-eslint/no-unsafe-member-access': 'off',
+    '@typescript-eslint/no-unsafe-return': 'off',
+  },
+}

package/.out/index.d.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/.out/index.js

@@ -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/.out/transformers/copies/copy.d.ts

@@ -0,0 +1,4 @@
+import { type ReadonlyTypeDefOf } from 'types/readonly_type_def_of';
+import { type StrictType } from 'types/strict_definitions';
+import { type ValueTypeOf } from 'types/value_type_of';
+export declare function copy<T extends StrictType>(t: T, proto: ValueTypeOf<ReadonlyTypeDefOf<T>>): ValueTypeOf<T>;

package/.out/transformers/copies/copy.js

@@ -0,0 +1,7 @@
+import { copyTo, } from './copy_to';
+function identity(v) {
+    return v;
+}
+export function copy(t, proto) {
+    return copyTo(t, proto, identity);
+}

package/.out/transformers/copies/copy_to.d.ts

@@ -0,0 +1,6 @@
+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';
+export type AnyValueType = any;
+export type Copier<R> = (v: AnyValueType, t: StrictTypeDef) => R;
+export declare function copyTo<T extends StrictType, R extends ValueTypeOf<ReadonlyTypeDefOf<T>>>({ definition }: T, value: ValueTypeOf<ReadonlyTypeDefOf<T>>, copier: Copier<R>): R;

package/.out/transformers/copies/copy_to.js

@@ -0,0 +1,91 @@
+import { map, reduce, UnexpectedImplementationError, UnreachableError, } from '@strictly/base';
+import { TypeDefType, } from 'types/definitions';
+export function copyTo({ definition }, value, copier) {
+    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(definition, value, copier) {
+    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(typeDef, value, copier) {
+    // mutable and immutable literals should be the same type
+    return copier(value, typeDef);
+}
+function copyList(typeDef, arr, copier) {
+    const { elements, } = typeDef;
+    const list = arr.map(function (value) {
+        return internalCopyTo(elements, value, copier);
+    });
+    return copier(list, typeDef);
+}
+function copyRecord(typeDef, value, copier) {
+    const { valueTypeDef, } = typeDef;
+    const record = map(value, function (_key, value) {
+        return internalCopyTo(valueTypeDef, value, copier);
+    });
+    return copier(record, typeDef);
+}
+function copyObjectFields(fields, value, copier, extra) {
+    const record = reduce(fields, function (acc, key, field) {
+        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);
+    return record;
+}
+function copyObject(typeDef, value, copier) {
+    const { fields, } = typeDef;
+    const record = copyObjectFields(fields, value, copier, {});
+    return copier(record, typeDef);
+}
+function copyUnion(typeDef, value, copier) {
+    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(unions);
+    const variableTypeDefs = allTypeDefs.filter(function (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/.out/transformers/copies/mobx_copy.d.ts

@@ -0,0 +1,5 @@
+import { type MobxValueTypeOf } from 'types/mobx_value_type_of';
+import { type ReadonlyTypeDefOf } from 'types/readonly_type_def_of';
+import { type StrictType } from 'types/strict_definitions';
+import { type ValueTypeOf } from 'types/value_type_of';
+export declare function mobxCopy<T extends StrictType>(t: T, proto: ValueTypeOf<ReadonlyTypeDefOf<T>>): MobxValueTypeOf<T>;

package/.out/transformers/copies/mobx_copy.js

@@ -0,0 +1,42 @@
+import { reduce, UnreachableError, } from '@strictly/base';
+import { makeObservable, observable, } from 'mobx';
+import { getUnionTypeDef } from 'transformers/flatteners/flatten_value_type_to';
+import { TypeDefType, } from 'types/definitions';
+import { copyTo, } from './copy_to';
+function observeValue(v, def) {
+    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, { deep: false });
+        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] = observable;
+                return acc;
+            }, 
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            {}), {
+                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, proto) {
+    return copyTo(t, proto, observeValue);
+}

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

@@ -0,0 +1 @@
+export {};

package/.out/transformers/copies/specs/copy_to.tests.js

@@ -0,0 +1,97 @@
+import { copyTo, } from 'transformers/copies/copy_to';
+import { booleanType, list, literal, numberType, object, record, stringType, union, } from 'types/builders';
+import { TypeDefType } from 'types/definitions';
+describe('copyTo', function () {
+    function toString(v, t) {
+        if (t.type === TypeDefType.Literal) {
+            return JSON.stringify(v);
+        }
+        else {
+            return v;
+        }
+    }
+    describe('literal', function () {
+        const type = literal();
+        it('copies', function () {
+            const c = copyTo(type, 1, toString);
+            expect(c).toEqual('1');
+        });
+    });
+    describe('list', function () {
+        const typeDef = list(literal());
+        it('copies', function () {
+            const c = copyTo(typeDef, [
+                1,
+                2,
+                3,
+            ], toString);
+            expect(c).toEqual([
+                '1',
+                '2',
+                '3',
+            ]);
+        });
+    });
+    describe('record', function () {
+        const typeDef = record(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/.out/transformers/copies/specs/mobx_copy.tests.d.ts

@@ -0,0 +1 @@
+export {};

package/.out/transformers/copies/specs/mobx_copy.tests.js

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

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

@@ -0,0 +1,5 @@
+import { type Type } from 'types/definitions';
+import { type Accessor, type FlattenedAccessorsOf } from 'types/flattened_accessors_of';
+import { type ValueTypeOf } from 'types/value_type_of';
+import { type Setter } from './flatten_value_type_to';
+export declare function flattenAccessorsOf<T extends Type, R extends Readonly<Record<string, Accessor<any>>> = FlattenedAccessorsOf<T>>(t: T, value: ValueTypeOf<T>, setValue: Setter<ValueTypeOf<T>>): R;

package/.out/transformers/flatteners/flatten_accessors_of.js

@@ -0,0 +1,11 @@
+import { flattenValueTypeTo, } from './flatten_value_type_to';
+function mapAccessor(_t, value, set) {
+    return {
+        value,
+        set,
+    };
+}
+export function flattenAccessorsOf(t, value, setValue) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return flattenValueTypeTo(t, value, setValue, mapAccessor);
+}

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

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

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

@@ -0,0 +1,10 @@
+import { flattenValueTypeTo, } from './flatten_value_type_to';
+function mapTypePaths(_t, _value, _set, typePath) {
+    return typePath;
+}
+export function flattenJsonValueToTypePathsOf(t, value) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return flattenValueTypeTo(t, value, function () {
+        // do nothing
+    }, mapTypePaths);
+}

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

@@ -0,0 +1,4 @@
+import { type StrictType, type StrictTypeDef } from 'types/strict_definitions';
+export type AnyValueType = any;
+export type Mapper<R> = (t: StrictTypeDef) => R;
+export declare function flattenTypeDefTo<M, R extends Readonly<Record<string, M>>>({ definition }: StrictType, mapper: Mapper<M>): R;

package/.out/transformers/flatteners/flatten_type_def_to.js

@@ -0,0 +1,49 @@
+import { reduce, UnreachableError, } from '@strictly/base';
+import { TypeDefType, } from 'types/definitions';
+import { jsonPath } from './json_path';
+export function flattenTypeDefTo({ definition }, mapper) {
+    const typeDefs = internalFlattenTypeDef('$', definition, {});
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return reduce(typeDefs, function (acc, key, typeDef) {
+        acc[key] = mapper(typeDef);
+        return acc;
+    }, 
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    {});
+}
+function internalFlattenTypeDef(path, t, r) {
+    r[path] = t;
+    return internalFlattenTypeDefChildren(path, '', t, r);
+}
+function internalFlattenTypeDefChildren(path, qualifier, t, r) {
+    switch (t.type) {
+        case TypeDefType.Literal:
+            return r;
+        case TypeDefType.List:
+            return internalFlattenedListTypeDefChildren(path, t, r);
+        case TypeDefType.Record:
+            return internalFlattenRecordTypeDefChildren(path, t, r);
+        case TypeDefType.Object:
+            return internalFlattenObjectTypeDefChildren(path, qualifier, t, r);
+        case TypeDefType.Union:
+            return internalFlattenUnionTypeDefChildren(path, qualifier, t, r);
+        default:
+            throw new UnreachableError(t);
+    }
+}
+function internalFlattenedListTypeDefChildren(path, { elements }, r) {
+    return internalFlattenTypeDef(jsonPath(path, '*'), elements, r);
+}
+function internalFlattenRecordTypeDefChildren(path, { valueTypeDef }, r) {
+    return internalFlattenTypeDef(jsonPath(path, '*'), valueTypeDef, r);
+}
+function internalFlattenObjectTypeDefChildren(path, qualifier, { fields }, r) {
+    return reduce(fields, function (acc, fieldName, fieldTypeDef) {
+        return internalFlattenTypeDef(jsonPath(path, fieldName, qualifier), fieldTypeDef, acc);
+    }, 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);
+    }, r);
+}

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

@@ -0,0 +1,3 @@
+import { type Type } from 'types/definitions';
+import { type StrictType } from 'types/strict_definitions';
+export declare function flattenTypeDefsOf<T extends StrictType>(t: T): Record<string, Type>;

package/.out/transformers/flatteners/flatten_type_defs_of.js

@@ -0,0 +1,7 @@
+import { flattenTypeDefTo } from './flatten_type_def_to';
+export function flattenTypeDefsOf(t) {
+    // Type should be FlattenedTypeDefsOf<T>, but infinite depth error
+    return flattenTypeDefTo(t, function (definition) {
+        return { definition };
+    });
+}

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

@@ -0,0 +1,11 @@
+import { type UnionTypeDef } from 'types/definitions';
+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';
+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 flattenValueTypeTo<T extends StrictType, M, R extends Readonly<Record<string, M>>>({ definition }: T, v: ValueTypeOf<T>, setter: Setter<ValueTypeOf<T>>, mapper: Mapper<M>): R;
+export declare function getUnionTypeDef<T extends UnionTypeDef>(typeDef: T, v: ValueTypeOf<ReadonlyTypeDefOf<{
+    definition: T;
+}>>): any;

package/.out/transformers/flatteners/flatten_value_type_to.js

@@ -0,0 +1,79 @@
+import { reduce, UnreachableError, } from '@strictly/base';
+import { TypeDefType, } from 'types/definitions';
+import { jsonPath } from './json_path';
+export function flattenValueTypeTo({ definition }, v, setter, mapper) {
+    const r = {};
+    internalFlattenValue('$', '$', definition, v, setter, mapper, r);
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return r;
+}
+function internalFlattenValue(valuePath, typePath, typeDef, v, setter, mapper, r) {
+    r[valuePath] = mapper(typeDef, v, setter, typePath, valuePath);
+    return internalFlattenValueChildren(valuePath, typePath, '', typeDef, v, mapper, r);
+}
+function internalFlattenValueChildren(valuePath, typePath, qualifier, typeDef, v, mapper, r) {
+    switch (typeDef.type) {
+        case TypeDefType.Literal:
+            // no children
+            return r;
+        case TypeDefType.List:
+            return internalFlattenListChildren(valuePath, typePath, typeDef, v, mapper, r);
+        case TypeDefType.Record:
+            return internalFlattenRecordChildren(valuePath, typePath, typeDef, v, mapper, r);
+        case TypeDefType.Object:
+            return internalFlattenObjectChildren(valuePath, typePath, qualifier, typeDef, v, mapper, r);
+        case TypeDefType.Union:
+            return internalFlattenUnionChildren(valuePath, typePath, qualifier, typeDef, v, mapper, r);
+        default:
+            throw new UnreachableError(typeDef);
+    }
+}
+function internalFlattenListChildren(valuePath, typePath, { elements }, v, mapper, r) {
+    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);
+    }, r);
+}
+function internalFlattenRecordChildren(valuePath, typePath, { valueTypeDef }, v, mapper, r) {
+    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);
+    }, r);
+}
+function internalFlattenObjectChildren(valuePath, typePath, qualifier, { 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) => {
+            v[k] = value;
+        }, mapper, r);
+    }, r);
+}
+function internalFlattenUnionChildren(valuePath, typePath, qualifier, 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);
+}
+export function getUnionTypeDef(typeDef, v) {
+    if (typeDef.discriminator == null) {
+        // find either a literal who's prototype we match, or assume that
+        // we match the non-literal, or the literal value with no prototype, value
+        return reduce(typeDef.unions, function (acc, _k, t) {
+            if (t.type === TypeDefType.Literal && t.valuePrototype) {
+                if (t.valuePrototype.indexOf(v) >= 0) {
+                    return t;
+                }
+            }
+            else {
+                if (acc == null) {
+                    return t;
+                }
+            }
+            return acc;
+        }, null);
+    }
+    return typeDef.unions[v[typeDef.discriminator]];
+}

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

@@ -0,0 +1,3 @@
+import { type Type } from 'types/definitions';
+import { type ValueTypeOf } from 'types/value_type_of';
+export declare function flattenValueTypesOf<T extends Type>(typeDef: Type, value: ValueTypeOf<T>): Readonly<Record<string, any>>;

package/.out/transformers/flatteners/flatten_value_types_of.js

@@ -0,0 +1,7 @@
+import { flattenValueTypeTo, } from './flatten_value_type_to';
+function mapper(_t, v) {
+    return v;
+}
+export function flattenValueTypesOf(typeDef, value) {
+    return flattenValueTypeTo(typeDef, value, () => { }, mapper);
+}

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

@@ -0,0 +1,2 @@
+export declare function jsonPath(prefix: string, segment: number | string, qualifier?: string): string;
+export declare function jsonPathPop(path: string): [string, string] | null;

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

@@ -0,0 +1,14 @@
+export function jsonPath(prefix, segment, qualifier = '') {
+    const s = `.${qualifier}${segment}`;
+    return `${prefix}${s}`;
+}
+export function jsonPathPop(path) {
+    const parts = path.split('.');
+    if (parts.length <= 1) {
+        return null;
+    }
+    return [
+        parts.slice(0, -1).join('.'),
+        parts.pop(),
+    ];
+}

package/.out/transformers/flatteners/specs/flatten_accessors_of.tests.d.ts

@@ -0,0 +1 @@
+export {};