@formvk/path 0.0.0-stage → 0.1.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/dist/index.d.ts +122 -0
- package/dist/index.js +1334 -0
- package/dist/index.js.map +1 -0
- package/package.json +19 -3
- package/src/__tests__/accessor.spec.ts +429 -0
- package/src/__tests__/basic.spec.ts +14 -0
- package/src/__tests__/match.spec.ts +280 -0
- package/src/__tests__/parser.spec.ts +689 -0
- package/src/__tests__/share.spec.ts +43 -0
- package/src/contexts.ts +23 -0
- package/src/destructor.ts +131 -0
- package/src/index.ts +583 -0
- package/src/matcher.ts +224 -0
- package/src/parser.ts +460 -0
- package/src/shared.ts +83 -0
- package/src/tokenizer.ts +306 -0
- package/src/tokens.ts +233 -0
- package/src/types.ts +133 -0
- package/tsconfig.build.json +9 -0
- package/tsconfig.json +4 -0
- package/vite.config.ts +22 -0
- package/README.md +0 -3
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 { }
|