How to use baseParse method in Playwright Internal

1const {
2  normalizeESLintConfig
3} = require("./configuration.cjs");
4
5const analyzeScope = require("./analyze-scope.cjs");
6
7const baseParse = require("./parse.cjs");
8
9const {
10  LocalClient,
11  WorkerClient
12} = require("./client.cjs");
13
14const client = new LocalClient();
15
16exports.parse = function (code, options = {}) {
17  return baseParse(code, normalizeESLintConfig(options), client);
18};
19
20exports.parseForESLint = function (code, options = {}) {
21  const normalizedOptions = normalizeESLintConfig(options);
22  const ast = baseParse(code, normalizedOptions, client);
23  const scopeManager = analyzeScope(ast, normalizedOptions, client);
24  return {
25    ast,
26    scopeManager,
27    visitorKeys: client.getVisitorKeys()
28  };
29};

Source: index.cjs

const {
  normalizeESLintConfig
} = require("./configuration.cjs");

const analyzeScope = require("./analyze-scope.cjs");

const baseParse = require("./parse.cjs");

const {
  LocalClient,
  WorkerClient
} = require("./client.cjs");

const client = new LocalClient();

exports.parse = function (code, options = {}) {
  return baseParse(code, normalizeESLintConfig(options), client);
};

exports.parseForESLint = function (code, options = {}) {
  const normalizedOptions = normalizeESLintConfig(options);
  const ast = baseParse(code, normalizedOptions, client);
  const scopeManager = analyzeScope(ast, normalizedOptions, client);
  return {
    ast,
    scopeManager,
    visitorKeys: client.getVisitorKeys()
  };
};

1/*jslint plusplus: false, strict: false */
2/*global define: false */
3
4/**
5 * An override for the jslib/parse.js to convert stealjs calls into
6 * require/define calls.
7 */
8
9define(['../../jslib/parse'], function (baseParse) {
10
11    var parse = baseParse,
12        allowedCalls = {
13            plugins: true,
14            views: true
15        },
16        viewStringRegExp = /^\/\//;
17
18    /**
19     * Finds a steal node in a nested, backwards AST tree structure.
20     */
21    function getStealCall(node) {
22        if (!baseParse.isArray(node)) {
23            return false;
24        }
25
26        if (node[0] === 'name' && node[1] === 'steal' && !node.isRequireJSParsed) {
27            return node;
28        } else if (node[0] === 'call') {
29            if (node[1][0] === 'name' && node[1][1] === 'steal') {
30                return getStealCall(node[1]);
31            } else if (node[1][0] === 'dot') {
32                return getStealCall(node[1][1]);
33            }
34        }
35
36        return null;
37    }
38
39    /**
40     * Mark the steal node tree as processed. Need to do this given the
41     * backwards structure of the AST.
42     */
43    function markStealTreeProcessed(node) {
44        getStealCall(node).isRequireJSParsed = true;
45    }
46
47    /**
48     * Transform a .views depdencency to an ejs! plugin loaded depdendency
49     * @param {String} value the .views string name.
50     * @returns {String} an 'ejs!' string
51     */
52    function viewTransform(value) {
53        return 'ejs!' + value.replace(viewStringRegExp, '');
54    }
55
56    function addStringsToArray(node, array, transform) {
57        var i, item, matches = [];
58        for (i = 0; i < node.length; i++) {
59            item = node[i];
60            if (item && baseParse.isArray(item) && item[0] === 'string') {
61                matches.push((transform ? transform(item[1]) : item[1]));
62            }
63        }
64
65        if (matches.length) {
66            //Build up arguments to splice, since we need to put these
67            //matches before other matches, given the backwards nature of
68            //the call traversal in the AST.
69            matches.unshift(0);
70            matches.unshift(0);
71            array.splice.apply(array, matches);
72        }
73    }
74
75    function generateRequireCall(node, array) {
76        if (!baseParse.isArray(node)) {
77            return;
78        }
79
80        var args, previous, call;
81
82        if (node[0] === 'call' && node[1][0] === 'name' && node[1][1] === 'steal') {
83            //A simple steal() call.
84            addStringsToArray(node[2], array);
85        } else {
86            //A chained call
87            //Need to unwind the call since the dot access shows up "backwards"
88            //in the AST.
89            args = node[node.length - 1];
90            previous = node[node.length - 2];
91            call = previous[previous.length - 1];
92
93            if (typeof call === 'string' && allowedCalls[call]) {
94                if (call === 'plugins') {
95                    addStringsToArray(args, array);
96                } else if (call === 'views') {
97                    addStringsToArray(args, array, viewTransform);
98                }
99
100                //Find out if there are any other chained calls.
101                previous = previous[previous.length - 2];
102
103                generateRequireCall(previous, array);
104            }
105        }
106    }
107
108    parse.oldParseNode = parse.parseNode;
109
110    parse.parseNode = function (node) {
111        var value;
112
113        if (!this.isArray(node)) {
114            return null;
115        }
116
117        //Allow files with regular define/require calls to be co-mingled
118        //with StealJS APIs.
119        value = this.oldParseNode(node);
120        if (value) {
121            return value;
122        }
123
124        if (getStealCall(node)) {
125            value = [];
126            generateRequireCall(node, value);
127            if (value.length) {
128                markStealTreeProcessed(node);
129                return "require(" + JSON.stringify(value) + ");";
130            } else {
131                return '';
132            }
133        }
134
135        return null;
136    };
137
138/*
139 use console.log(JSON.stringify(node, null, '  ')) to print out AST
140
141 Using this:
142 steal.plugins('foo','bar').views('//abc/init.ejs').then(function(){})
143
144 Has this for one of the nodes.
145
146[
147  "call",
148  [
149    "dot",
150    [
151      "call",
152      [
153        "dot",
154        [
155          "name",
156          "steal"
157        ],
158        "plugins"
159      ],
160      [
161        [
162          "string",
163          "foo"
164        ],
165        [
166          "string",
167          "bar"
168        ]
169      ]
170    ],
171    "views"
172  ],
173  [
174    [
175      "string",
176      "//abc/init.ejs"
177    ]
178  ]
179]
180
181**************************
182
183steal('one', 'two')
184
185[
186  "toplevel",
187  [
188    [
189      "stat",
190      [
191        "call",
192        [
193          "name",
194          "steal"
195        ],
196        [
197          [
198            "string",
199            "one"
200          ],
201          [
202            "string",
203            "two"
204          ]
205        ]
206      ]
207    ]
208  ]
209]
210
211*/
212
213    return parse;
214});
215

Source: parse.js

/*jslint plusplus: false, strict: false */
/*global define: false */

/**
 * An override for the jslib/parse.js to convert stealjs calls into
 * require/define calls.
 */

define(['../../jslib/parse'], function (baseParse) {

    var parse = baseParse,
        allowedCalls = {
            plugins: true,
            views: true
        },
        viewStringRegExp = /^\/\//;

    /**
     * Finds a steal node in a nested, backwards AST tree structure.
     */
    function getStealCall(node) {
        if (!baseParse.isArray(node)) {
            return false;
        }

        if (node[0] === 'name' && node[1] === 'steal' && !node.isRequireJSParsed) {
            return node;
        } else if (node[0] === 'call') {
            if (node[1][0] === 'name' && node[1][1] === 'steal') {
                return getStealCall(node[1]);
            } else if (node[1][0] === 'dot') {
                return getStealCall(node[1][1]);
            }
        }

        return null;
    }

    /**
     * Mark the steal node tree as processed. Need to do this given the
     * backwards structure of the AST.
     */
    function markStealTreeProcessed(node) {
        getStealCall(node).isRequireJSParsed = true;
    }

    /**
     * Transform a .views depdencency to an ejs! plugin loaded depdendency
     * @param {String} value the .views string name.
     * @returns {String} an 'ejs!' string
     */
    function viewTransform(value) {
        return 'ejs!' + value.replace(viewStringRegExp, '');
    }

    function addStringsToArray(node, array, transform) {
        var i, item, matches = [];
        for (i = 0; i < node.length; i++) {
            item = node[i];
            if (item && baseParse.isArray(item) && item[0] === 'string') {
                matches.push((transform ? transform(item[1]) : item[1]));
            }
        }

        if (matches.length) {
            //Build up arguments to splice, since we need to put these
            //matches before other matches, given the backwards nature of
            //the call traversal in the AST.
            matches.unshift(0);
            matches.unshift(0);
            array.splice.apply(array, matches);
        }
    }

    function generateRequireCall(node, array) {
        if (!baseParse.isArray(node)) {
            return;
        }

        var args, previous, call;

        if (node[0] === 'call' && node[1][0] === 'name' && node[1][1] === 'steal') {
            //A simple steal() call.
            addStringsToArray(node[2], array);
        } else {
            //A chained call
            //Need to unwind the call since the dot access shows up "backwards"
            //in the AST.
            args = node[node.length - 1];
            previous = node[node.length - 2];
            call = previous[previous.length - 1];

            if (typeof call === 'string' && allowedCalls[call]) {
                if (call === 'plugins') {
                    addStringsToArray(args, array);
                } else if (call === 'views') {
                    addStringsToArray(args, array, viewTransform);
                }

                //Find out if there are any other chained calls.
                previous = previous[previous.length - 2];

                generateRequireCall(previous, array);
            }
        }
    }

    parse.oldParseNode = parse.parseNode;

    parse.parseNode = function (node) {
        var value;

        if (!this.isArray(node)) {
            return null;
        }

        //Allow files with regular define/require calls to be co-mingled
        //with StealJS APIs.
        value = this.oldParseNode(node);
        if (value) {
            return value;
        }

        if (getStealCall(node)) {
            value = [];
            generateRequireCall(node, value);
            if (value.length) {
                markStealTreeProcessed(node);
                return "require(" + JSON.stringify(value) + ");";
            } else {
                return '';
            }
        }

        return null;
    };

/*
 use console.log(JSON.stringify(node, null, '  ')) to print out AST

 Using this:
 steal.plugins('foo','bar').views('//abc/init.ejs').then(function(){})

 Has this for one of the nodes.

[
  "call",
  [
    "dot",
    [
      "call",
      [
        "dot",
        [
          "name",
          "steal"
        ],
        "plugins"
      ],
      [
        [
          "string",
          "foo"
        ],
        [
          "string",
          "bar"
        ]
      ]
    ],
    "views"
  ],
  [
    [
      "string",
      "//abc/init.ejs"
    ]
  ]
]

**************************

steal('one', 'two')

[
  "toplevel",
  [
    [
      "stat",
      [
        "call",
        [
          "name",
          "steal"
        ],
        [
          [
            "string",
            "one"
          ],
          [
            "string",
            "two"
          ]
        ]
      ]
    ]
  ]
]

*/

    return parse;
});