source: imaps-frontend/node_modules/@babel/traverse/lib/path/index.js@ 0c6b92a

main
Last change on this file since 0c6b92a was 0c6b92a, checked in by stefan toskovski <stefantoska84@…>, 5 weeks ago

Pred finalna verzija
  • Property mode set to 100644
File size: 11.0 KB
Line 
1"use strict";
2
3Object.defineProperty(exports, "__esModule", {
4 value: true
5});
6exports.default = exports.SHOULD_STOP = exports.SHOULD_SKIP = exports.REMOVED = void 0;
7var virtualTypes = require("./lib/virtual-types.js");
8var _debug = require("debug");
9var _index = require("../index.js");
10var _index2 = require("../scope/index.js");
11var _t = require("@babel/types");
12var t = _t;
13var cache = require("../cache.js");
14var _generator = require("@babel/generator");
15var NodePath_ancestry = require("./ancestry.js");
16var NodePath_inference = require("./inference/index.js");
17var NodePath_replacement = require("./replacement.js");
18var NodePath_evaluation = require("./evaluation.js");
19var NodePath_conversion = require("./conversion.js");
20var NodePath_introspection = require("./introspection.js");
21var _context = require("./context.js");
22var NodePath_context = _context;
23var NodePath_removal = require("./removal.js");
24var NodePath_modification = require("./modification.js");
25var NodePath_family = require("./family.js");
26var NodePath_comments = require("./comments.js");
27var NodePath_virtual_types_validator = require("./lib/virtual-types-validator.js");
28const {
29 validate
30} = _t;
31const debug = _debug("babel");
32const REMOVED = exports.REMOVED = 1 << 0;
33const SHOULD_STOP = exports.SHOULD_STOP = 1 << 1;
34const SHOULD_SKIP = exports.SHOULD_SKIP = 1 << 2;
35const NodePath_Final = exports.default = class NodePath {
36 constructor(hub, parent) {
37 this.contexts = [];
38 this.state = null;
39 this.opts = null;
40 this._traverseFlags = 0;
41 this.skipKeys = null;
42 this.parentPath = null;
43 this.container = null;
44 this.listKey = null;
45 this.key = null;
46 this.node = null;
47 this.type = null;
48 this.parent = parent;
49 this.hub = hub;
50 this.data = null;
51 this.context = null;
52 this.scope = null;
53 }
54 get removed() {
55 return (this._traverseFlags & 1) > 0;
56 }
57 set removed(v) {
58 if (v) this._traverseFlags |= 1;else this._traverseFlags &= -2;
59 }
60 get shouldStop() {
61 return (this._traverseFlags & 2) > 0;
62 }
63 set shouldStop(v) {
64 if (v) this._traverseFlags |= 2;else this._traverseFlags &= -3;
65 }
66 get shouldSkip() {
67 return (this._traverseFlags & 4) > 0;
68 }
69 set shouldSkip(v) {
70 if (v) this._traverseFlags |= 4;else this._traverseFlags &= -5;
71 }
72 static get({
73 hub,
74 parentPath,
75 parent,
76 container,
77 listKey,
78 key
79 }) {
80 if (!hub && parentPath) {
81 hub = parentPath.hub;
82 }
83 if (!parent) {
84 throw new Error("To get a node path the parent needs to exist");
85 }
86 const targetNode = container[key];
87 const paths = cache.getOrCreateCachedPaths(hub, parent);
88 let path = paths.get(targetNode);
89 if (!path) {
90 path = new NodePath(hub, parent);
91 if (targetNode) paths.set(targetNode, path);
92 }
93 _context.setup.call(path, parentPath, container, listKey, key);
94 return path;
95 }
96 getScope(scope) {
97 return this.isScope() ? new _index2.default(this) : scope;
98 }
99 setData(key, val) {
100 if (this.data == null) {
101 this.data = Object.create(null);
102 }
103 return this.data[key] = val;
104 }
105 getData(key, def) {
106 if (this.data == null) {
107 this.data = Object.create(null);
108 }
109 let val = this.data[key];
110 if (val === undefined && def !== undefined) val = this.data[key] = def;
111 return val;
112 }
113 hasNode() {
114 return this.node != null;
115 }
116 buildCodeFrameError(msg, Error = SyntaxError) {
117 return this.hub.buildError(this.node, msg, Error);
118 }
119 traverse(visitor, state) {
120 (0, _index.default)(this.node, visitor, this.scope, state, this);
121 }
122 set(key, node) {
123 validate(this.node, key, node);
124 this.node[key] = node;
125 }
126 getPathLocation() {
127 const parts = [];
128 let path = this;
129 do {
130 let key = path.key;
131 if (path.inList) key = `${path.listKey}[${key}]`;
132 parts.unshift(key);
133 } while (path = path.parentPath);
134 return parts.join(".");
135 }
136 debug(message) {
137 if (!debug.enabled) return;
138 debug(`${this.getPathLocation()} ${this.type}: ${message}`);
139 }
140 toString() {
141 return (0, _generator.default)(this.node).code;
142 }
143 get inList() {
144 return !!this.listKey;
145 }
146 set inList(inList) {
147 if (!inList) {
148 this.listKey = null;
149 }
150 }
151 get parentKey() {
152 return this.listKey || this.key;
153 }
154};
155const methods = {
156 findParent: NodePath_ancestry.findParent,
157 find: NodePath_ancestry.find,
158 getFunctionParent: NodePath_ancestry.getFunctionParent,
159 getStatementParent: NodePath_ancestry.getStatementParent,
160 getEarliestCommonAncestorFrom: NodePath_ancestry.getEarliestCommonAncestorFrom,
161 getDeepestCommonAncestorFrom: NodePath_ancestry.getDeepestCommonAncestorFrom,
162 getAncestry: NodePath_ancestry.getAncestry,
163 isAncestor: NodePath_ancestry.isAncestor,
164 isDescendant: NodePath_ancestry.isDescendant,
165 inType: NodePath_ancestry.inType,
166 getTypeAnnotation: NodePath_inference.getTypeAnnotation,
167 isBaseType: NodePath_inference.isBaseType,
168 couldBeBaseType: NodePath_inference.couldBeBaseType,
169 baseTypeStrictlyMatches: NodePath_inference.baseTypeStrictlyMatches,
170 isGenericType: NodePath_inference.isGenericType,
171 replaceWithMultiple: NodePath_replacement.replaceWithMultiple,
172 replaceWithSourceString: NodePath_replacement.replaceWithSourceString,
173 replaceWith: NodePath_replacement.replaceWith,
174 replaceExpressionWithStatements: NodePath_replacement.replaceExpressionWithStatements,
175 replaceInline: NodePath_replacement.replaceInline,
176 evaluateTruthy: NodePath_evaluation.evaluateTruthy,
177 evaluate: NodePath_evaluation.evaluate,
178 toComputedKey: NodePath_conversion.toComputedKey,
179 ensureBlock: NodePath_conversion.ensureBlock,
180 unwrapFunctionEnvironment: NodePath_conversion.unwrapFunctionEnvironment,
181 arrowFunctionToExpression: NodePath_conversion.arrowFunctionToExpression,
182 splitExportDeclaration: NodePath_conversion.splitExportDeclaration,
183 ensureFunctionName: NodePath_conversion.ensureFunctionName,
184 matchesPattern: NodePath_introspection.matchesPattern,
185 isStatic: NodePath_introspection.isStatic,
186 isNodeType: NodePath_introspection.isNodeType,
187 canHaveVariableDeclarationOrExpression: NodePath_introspection.canHaveVariableDeclarationOrExpression,
188 canSwapBetweenExpressionAndStatement: NodePath_introspection.canSwapBetweenExpressionAndStatement,
189 isCompletionRecord: NodePath_introspection.isCompletionRecord,
190 isStatementOrBlock: NodePath_introspection.isStatementOrBlock,
191 referencesImport: NodePath_introspection.referencesImport,
192 getSource: NodePath_introspection.getSource,
193 willIMaybeExecuteBefore: NodePath_introspection.willIMaybeExecuteBefore,
194 _guessExecutionStatusRelativeTo: NodePath_introspection._guessExecutionStatusRelativeTo,
195 resolve: NodePath_introspection.resolve,
196 isConstantExpression: NodePath_introspection.isConstantExpression,
197 isInStrictMode: NodePath_introspection.isInStrictMode,
198 isDenylisted: NodePath_context.isDenylisted,
199 visit: NodePath_context.visit,
200 skip: NodePath_context.skip,
201 skipKey: NodePath_context.skipKey,
202 stop: NodePath_context.stop,
203 setContext: NodePath_context.setContext,
204 requeue: NodePath_context.requeue,
205 requeueComputedKeyAndDecorators: NodePath_context.requeueComputedKeyAndDecorators,
206 remove: NodePath_removal.remove,
207 insertBefore: NodePath_modification.insertBefore,
208 insertAfter: NodePath_modification.insertAfter,
209 unshiftContainer: NodePath_modification.unshiftContainer,
210 pushContainer: NodePath_modification.pushContainer,
211 getOpposite: NodePath_family.getOpposite,
212 getCompletionRecords: NodePath_family.getCompletionRecords,
213 getSibling: NodePath_family.getSibling,
214 getPrevSibling: NodePath_family.getPrevSibling,
215 getNextSibling: NodePath_family.getNextSibling,
216 getAllNextSiblings: NodePath_family.getAllNextSiblings,
217 getAllPrevSiblings: NodePath_family.getAllPrevSiblings,
218 get: NodePath_family.get,
219 getAssignmentIdentifiers: NodePath_family.getAssignmentIdentifiers,
220 getBindingIdentifiers: NodePath_family.getBindingIdentifiers,
221 getOuterBindingIdentifiers: NodePath_family.getOuterBindingIdentifiers,
222 getBindingIdentifierPaths: NodePath_family.getBindingIdentifierPaths,
223 getOuterBindingIdentifierPaths: NodePath_family.getOuterBindingIdentifierPaths,
224 shareCommentsWithSiblings: NodePath_comments.shareCommentsWithSiblings,
225 addComment: NodePath_comments.addComment,
226 addComments: NodePath_comments.addComments
227};
228Object.assign(NodePath_Final.prototype, methods);
229{
230 NodePath_Final.prototype.arrowFunctionToShadowed = NodePath_conversion[String("arrowFunctionToShadowed")];
231 Object.assign(NodePath_Final.prototype, {
232 has: NodePath_introspection[String("has")],
233 is: NodePath_introspection[String("is")],
234 isnt: NodePath_introspection[String("isnt")],
235 equals: NodePath_introspection[String("equals")],
236 hoist: NodePath_modification[String("hoist")],
237 updateSiblingKeys: NodePath_modification.updateSiblingKeys,
238 call: NodePath_context.call,
239 isBlacklisted: NodePath_context[String("isBlacklisted")],
240 setScope: NodePath_context.setScope,
241 resync: NodePath_context.resync,
242 popContext: NodePath_context.popContext,
243 pushContext: NodePath_context.pushContext,
244 setup: NodePath_context.setup,
245 setKey: NodePath_context.setKey
246 });
247}
248{
249 NodePath_Final.prototype._guessExecutionStatusRelativeToDifferentFunctions = NodePath_introspection._guessExecutionStatusRelativeTo;
250 NodePath_Final.prototype._guessExecutionStatusRelativeToDifferentFunctions = NodePath_introspection._guessExecutionStatusRelativeTo;
251 Object.assign(NodePath_Final.prototype, {
252 _getTypeAnnotation: NodePath_inference._getTypeAnnotation,
253 _replaceWith: NodePath_replacement._replaceWith,
254 _resolve: NodePath_introspection._resolve,
255 _call: NodePath_context._call,
256 _resyncParent: NodePath_context._resyncParent,
257 _resyncKey: NodePath_context._resyncKey,
258 _resyncList: NodePath_context._resyncList,
259 _resyncRemoved: NodePath_context._resyncRemoved,
260 _getQueueContexts: NodePath_context._getQueueContexts,
261 _removeFromScope: NodePath_removal._removeFromScope,
262 _callRemovalHooks: NodePath_removal._callRemovalHooks,
263 _remove: NodePath_removal._remove,
264 _markRemoved: NodePath_removal._markRemoved,
265 _assertUnremoved: NodePath_removal._assertUnremoved,
266 _containerInsert: NodePath_modification._containerInsert,
267 _containerInsertBefore: NodePath_modification._containerInsertBefore,
268 _containerInsertAfter: NodePath_modification._containerInsertAfter,
269 _verifyNodeList: NodePath_modification._verifyNodeList,
270 _getKey: NodePath_family._getKey,
271 _getPattern: NodePath_family._getPattern
272 });
273}
274for (const type of t.TYPES) {
275 const typeKey = `is${type}`;
276 const fn = t[typeKey];
277 NodePath_Final.prototype[typeKey] = function (opts) {
278 return fn(this.node, opts);
279 };
280 NodePath_Final.prototype[`assert${type}`] = function (opts) {
281 if (!fn(this.node, opts)) {
282 throw new TypeError(`Expected node path of type ${type}`);
283 }
284 };
285}
286Object.assign(NodePath_Final.prototype, NodePath_virtual_types_validator);
287for (const type of Object.keys(virtualTypes)) {
288 if (type[0] === "_") continue;
289 if (!t.TYPES.includes(type)) t.TYPES.push(type);
290}
291
292//# sourceMappingURL=index.js.map
Note: See TracBrowser for help on using the repository browser.