Objects.AllPaths leaves only + ignore selected types

[marek-hanzal]

Hello,

Maybe it's possible, but I just want to ask, if it's possible to get only leaves of an object, eventually filter out (ignore) specified types of an object (for example DateTime or so)?

type Foo = Call<Objects.AllPaths, {
    foo: number;
    bar: {
        foo: number;
        bar: number;
    }
}>;

const SomeFoo: Record<Foo, any> = {
    "foo":     "123",
    "bar":     "123",  // <<-- I wanna ignore this (and others "roots")
    "bar.foo": "123",
    "bar.bar": "123",
};

Related to question

type Foo = Call<Objects.AllPaths, {
    foo: number;
    bar: {
        foo: number;
        bar: number;
    };
    foo2: {
        yep: string;
        nope: Date;
        ignoreMe: SomeIgnoredType;
    };
}, SomeIgnoredType | Date>;

// sould result in
const SomeFoo: Record<Foo, any> = {
    "foo":     "123",
    "bar.foo": "123",
    "bar.bar": "123",
    "foo2.yep": "123",
};

Thank you :)

[2mer]

Im new to hotscript so this can definately be written in a better way
I needed something similar for my project, heres my impl:

import { Fn, Objects, Pipe, Tuples, Call, Unions, ComposeLeft, _, PartialApply } from 'hotscript';
import { unset } from 'hotscript/dist/internals/core/Core';
import { Primitive } from 'hotscript/dist/internals/helpers';

export interface IsLeaf extends Fn {
	return: this['arg0'] extends Primitive ? (true) : (keyof this['arg0'] extends never ? true : false)
}

export type PathToEntry<path extends string | number | _ | unset = unset, obj = unset> = PartialApply<PathToEntryFn, [path, obj]>
export interface PathToEntryFn extends Fn {
	return: [
		this['arg0'],
		Call<
			Objects.Get<this['arg0']>,
			this['arg1']
		>
	]
}

export interface EntriesDeep extends Fn {
	return: Pipe<
		this['arg0'],
		[
			Objects.AllPaths,
			Unions.ToTuple,
			Tuples.Map<PathToEntry<_, this['arg0']>>,
		]
	>
}

export type Leaves = ComposeLeft<[
	EntriesDeep,
	Tuples.Filter<
		ComposeLeft<[
			Tuples.At<1>,
			IsLeaf
		]>
	>,
]>

const testObject = {
	a: 5,
	b: {
		c: 6
	},
	z: 'hello world',
	w: {
		a: {
			b: {
				c: 'nice',
				doSomething() { }
			}
		}
	}
} as const;

type test = Call<Leaves, typeof testObject>;
// [["a", 5], ["z", "hello world"], ["b.c", 6], ["w.a.b.c", "nice"], ["w.a.b.doSomething", () => void]]

its a little long but the type names should be semantic enough I hope 😅