davi-alexandre / leavify Goto Github PK

• default export.
• Figure out why import intellisense sometimes keeps suggesting the dist folder.
• write more tests, to cover the function arguments as well.
• Change package description
• start with the readme.
• Rename the function toChangeSet, since it refers to the type Changes and not ChangeSet.
• remove the type ChangeSet.
• Consider removing the Change and Changes types.
• Throw error instead of returning empty object in get() for the leaf values that do not exist; use has() instead.
• Return the changed leaf instead of type Change in findChanges(), given it's a special case for the mapLeaf() argument and harder to programatically read.
• Consider the return type of toTree(), as other than unknown. [object]
• Add Branch type

Forgot to mention in the commit message, but ba1cd1f deletes the functionality which autocompletes a leaf-path and its leaf-value.
The reason for it is that typescript gets too slow. "To much type instantiation", thinking it was possibly infinite.

I think the problem was the use of three recursive types in a row, namely Fragment<T> = Tree<RecursivePartial<T>>, and finally LeafPath<Fragment<T>>. The solution was to just ask whether T extends Fragment.

So... I'll be getting back to this later, and check whether the lagging continues. Specifically, the deleted types are:

1. LeafValue - which autocompletes for the possible values (when using as const) or their general type.
2. PathLeafPair - the path and either its as const value or its general type.

const sample = [42, {prop: 'value'}] as const;
const pair: PathLeafPair<typeof sample> = ['[1].prop', 'value'] // or ['[0]', 42]

Consider not using any symbols, using the original and proposed properties directly, assuming these are not already present in the prototype.
Try to create class instances with these names as inherited fields or methods, and see if they collide or smth
I think they are stored 2 levels deep in the instance's prototypal inheritance chain, idk

Issue microsoft/TypeScript#57545

The workaround will be to suggest hard value hints such as:

type Input = (
  | Primitive
  | Record<string, Primitive>
  | Record<number, Primitive>
  | Primitive[]
)[];

type Output =
  | `[${number | ''}]`
  | `[${number | ''}][${number | ''}]`
  | `[${number | ''}].${string | number}`
  | `[${number | ''}]${'$' | '#'}`;

class Book {
  title: string;
  chapters: Chapter[];
}
class Chapter {
  book: Book;
}
const path: LeafPath<Book> = 'title';

=> Results in path: any or Type instantiation is excessively deep and possibly infinite.ts(2589)

Possible solutions

1. Ideal solution: interpolate circular reference to any

It works hand-to-hand with RecursivePartial, that can provide intellisense for an arbitrary depth. In the above case, it would interpolate to:

path: `chapters[${number}].book${any}`

2. Omit from type

• detect circular reference in type automatically, or
• rely on the user omitting it from the type, as in:

  const path: LeafPath<Omit<Book, 'chapters'>> = 'title'

typescript-eslint/typescript-eslint#5586

Totally useless for leaf value comparison.
I think it used to have one, when mapLeaf was also a thing... mapping to objects!? Too much stuff for a single function lol

You don't always need the entirety of the object right away, as it is with the case of isBranch().