@formvk/path 0.0.0-stage → 1.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +7 -0
- package/README.md +49 -2
- package/dist/index.d.ts +122 -0
- package/dist/index.js +1334 -0
- package/dist/index.js.map +1 -0
- package/package.json +23 -3
package/CHANGELOG.md
ADDED
package/README.md
CHANGED
|
@@ -1,3 +1,50 @@
|
|
|
1
|
-
#
|
|
1
|
+
# @formvk/path
|
|
2
2
|
|
|
3
|
-
|
|
3
|
+
Path parsing and data access utilities used by Formvk to address fields. Supports dot paths, array indices, wildcard match patterns, relative paths and reusable matchers.
|
|
4
|
+
|
|
5
|
+
## Install
|
|
6
|
+
|
|
7
|
+
```bash
|
|
8
|
+
pnpm add @formvk/path
|
|
9
|
+
```
|
|
10
|
+
|
|
11
|
+
## Usage
|
|
12
|
+
|
|
13
|
+
```ts
|
|
14
|
+
import { Path } from '@formvk/path'
|
|
15
|
+
|
|
16
|
+
const values = { user: { name: 'alice' } }
|
|
17
|
+
|
|
18
|
+
Path.getIn(values, 'user.name') // 'alice'
|
|
19
|
+
Path.setIn(values, 'user.name', 'bob')
|
|
20
|
+
Path.existIn(values, 'user.name') // true
|
|
21
|
+
Path.deleteIn(values, 'user.name')
|
|
22
|
+
|
|
23
|
+
new Path('user.*').match('user.name') // true
|
|
24
|
+
new Path('user.name').includes('user') // true
|
|
25
|
+
Path.transform('user.name', /name/, key => key.toUpperCase()) // 'NAME'
|
|
26
|
+
```
|
|
27
|
+
|
|
28
|
+
`Path.match` creates a matcher that can be passed to `Form.query`:
|
|
29
|
+
|
|
30
|
+
```ts
|
|
31
|
+
form.query(Path.match('user.*')).forEach(field => {
|
|
32
|
+
field.setPattern('disabled')
|
|
33
|
+
})
|
|
34
|
+
```
|
|
35
|
+
|
|
36
|
+
## API
|
|
37
|
+
|
|
38
|
+
- **Instance** — `segments`, `entire`, `length`, `toString`, `toArr`, `concat`, `push`, `slice`, `pop`, `splice`, `parent`, `forEach`, `map`, `reduce`, `includes`, `match`, `matchAliasGroup`, `transform`, `getIn`, `setIn`, `deleteIn`, `existIn`, `ensureIn`.
|
|
39
|
+
- **Static** — `Path.parse`, `Path.getIn`, `Path.setIn`, `Path.deleteIn`, `Path.existIn`, `Path.ensureIn`, `Path.match`, `Path.transform`, `Path.isPathPattern`.
|
|
40
|
+
- **Types** — `Pattern`, `MatcherFunction`.
|
|
41
|
+
|
|
42
|
+
`@formvk/shared` re-exports the class as `FormPath` together with the `FormPathPattern` type.
|
|
43
|
+
|
|
44
|
+
## Documentation
|
|
45
|
+
|
|
46
|
+
https://formvk.github.io/core/api/core
|
|
47
|
+
|
|
48
|
+
## License
|
|
49
|
+
|
|
50
|
+
MIT
|
package/dist/index.d.ts
ADDED
|
@@ -0,0 +1,122 @@
|
|
|
1
|
+
declare type ArrayPatternNode = {
|
|
2
|
+
type: 'ArrayPattern';
|
|
3
|
+
elements: ObjectPatternNode[] | ArrayPatternNode[] | IdentifierNode[];
|
|
4
|
+
} & INode;
|
|
5
|
+
|
|
6
|
+
declare type DestructorExpressionNode = {
|
|
7
|
+
type: 'DestructorExpression';
|
|
8
|
+
value?: ObjectPatternNode | ArrayPatternNode;
|
|
9
|
+
source?: string;
|
|
10
|
+
} & INode;
|
|
11
|
+
|
|
12
|
+
declare type DotOperatorNode = {
|
|
13
|
+
type: 'DotOperator';
|
|
14
|
+
} & INode;
|
|
15
|
+
|
|
16
|
+
declare type ExpandOperatorNode = {
|
|
17
|
+
type: 'ExpandOperator';
|
|
18
|
+
} & INode;
|
|
19
|
+
|
|
20
|
+
declare type GroupExpressionNode = {
|
|
21
|
+
type: 'GroupExpression';
|
|
22
|
+
value: Node_2[];
|
|
23
|
+
isExclude?: boolean;
|
|
24
|
+
} & INode;
|
|
25
|
+
|
|
26
|
+
declare type IdentifierNode = {
|
|
27
|
+
type: 'Identifier';
|
|
28
|
+
value: string;
|
|
29
|
+
arrayIndex?: boolean;
|
|
30
|
+
} & INode;
|
|
31
|
+
|
|
32
|
+
declare interface INode {
|
|
33
|
+
type?: string;
|
|
34
|
+
after?: Node_2;
|
|
35
|
+
depth?: number;
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
declare const isMatcher: unique symbol;
|
|
39
|
+
|
|
40
|
+
declare type MatcherFunction = ((path: Pattern) => boolean) & {
|
|
41
|
+
path: Path;
|
|
42
|
+
};
|
|
43
|
+
|
|
44
|
+
declare type Node_2 = IdentifierNode | WildcardOperatorNode | GroupExpressionNode | RangeExpressionNode | DestructorExpressionNode | ObjectPatternNode | ArrayPatternNode | DotOperatorNode | ExpandOperatorNode | INode;
|
|
45
|
+
|
|
46
|
+
declare type ObjectPatternNode = {
|
|
47
|
+
type: 'ObjectPattern';
|
|
48
|
+
properties: ObjectPatternPropertyNode[];
|
|
49
|
+
} & INode;
|
|
50
|
+
|
|
51
|
+
declare type ObjectPatternPropertyNode = {
|
|
52
|
+
type: 'ObjectPatternProperty';
|
|
53
|
+
key: IdentifierNode;
|
|
54
|
+
value?: ObjectPatternNode[] | ArrayPatternNode[] | IdentifierNode;
|
|
55
|
+
} & INode;
|
|
56
|
+
|
|
57
|
+
export declare class Path {
|
|
58
|
+
entire: string | RegExp;
|
|
59
|
+
segments: Segments;
|
|
60
|
+
isMatchPattern: boolean;
|
|
61
|
+
isWildMatchPattern: boolean;
|
|
62
|
+
isRegExp: boolean;
|
|
63
|
+
haveRelativePattern: boolean;
|
|
64
|
+
haveExcludePattern: boolean;
|
|
65
|
+
matchScore: number;
|
|
66
|
+
tree: Node_2;
|
|
67
|
+
private matchCache;
|
|
68
|
+
private includesCache;
|
|
69
|
+
constructor(input: Pattern, base?: Pattern);
|
|
70
|
+
toString(): string;
|
|
71
|
+
toArr(): (string | number)[];
|
|
72
|
+
get length(): number;
|
|
73
|
+
concat: (...args: Pattern[]) => Path;
|
|
74
|
+
slice: (start?: number, end?: number) => Path;
|
|
75
|
+
push: (...items: Pattern[]) => Path;
|
|
76
|
+
pop: () => Path;
|
|
77
|
+
splice: (start: number, deleteCount?: number, ...items: Array<string | number>) => Path;
|
|
78
|
+
forEach: (callback: (key: string | number) => any) => void;
|
|
79
|
+
map: (callback: (key: string | number) => any) => any[];
|
|
80
|
+
reduce: <T>(callback: (buf: T, item: string | number, index: number) => T, initial: T) => T;
|
|
81
|
+
parent: () => Path;
|
|
82
|
+
includes: (pattern: Pattern) => any;
|
|
83
|
+
transform: <T>(regexp: string | RegExp, callback: (...args: string[]) => T) => T | string;
|
|
84
|
+
match: (pattern: Pattern) => boolean;
|
|
85
|
+
matchAliasGroup: (name: Pattern, alias: Pattern) => boolean;
|
|
86
|
+
existIn: (source?: any, start?: number | Path) => boolean | undefined;
|
|
87
|
+
getIn: (source?: any) => any;
|
|
88
|
+
setIn: (source?: any, value?: any) => any;
|
|
89
|
+
deleteIn: (source?: any) => any;
|
|
90
|
+
ensureIn: (source?: any, defaults?: any) => any;
|
|
91
|
+
static match(pattern: Pattern): ((path: Pattern) => boolean) & {
|
|
92
|
+
path: Path;
|
|
93
|
+
} & {
|
|
94
|
+
[isMatcher]: true;
|
|
95
|
+
};
|
|
96
|
+
static isPathPattern(target: any): target is Pattern;
|
|
97
|
+
static transform<T>(pattern: Pattern, regexp: string | RegExp, callback: (...args: string[]) => T): any;
|
|
98
|
+
static parse(path?: Pattern, base?: Pattern): Path;
|
|
99
|
+
static getIn: (source: any, pattern: Pattern) => any;
|
|
100
|
+
static setIn: (source: any, pattern: Pattern, value: any) => any;
|
|
101
|
+
static deleteIn: (source: any, pattern: Pattern) => any;
|
|
102
|
+
static existIn: (source: any, pattern: Pattern, start?: number | Path) => boolean | undefined;
|
|
103
|
+
static ensureIn: (source: any, pattern: Pattern, defaultValue?: any) => any;
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
export declare type Pattern = string | number | Path | Segments | MatcherFunction | RegExp;
|
|
107
|
+
|
|
108
|
+
declare type RangeExpressionNode = {
|
|
109
|
+
type: 'RangeExpression';
|
|
110
|
+
start?: IdentifierNode;
|
|
111
|
+
end?: IdentifierNode;
|
|
112
|
+
} & INode;
|
|
113
|
+
|
|
114
|
+
declare type Segments = Array<string | number>;
|
|
115
|
+
|
|
116
|
+
declare type WildcardOperatorNode = {
|
|
117
|
+
type: 'WildcardOperator';
|
|
118
|
+
filter?: GroupExpressionNode | RangeExpressionNode;
|
|
119
|
+
optional?: boolean;
|
|
120
|
+
} & INode;
|
|
121
|
+
|
|
122
|
+
export { }
|