@mapled/cli 0.12.0 → 0.14.0

package/dist/scan.d.ts

@@ -61,7 +61,7 @@ export declare function detectRoutes(files: string[], framework: string | null):
     name; `unclosed`: a quoted string a line break (or the end) cut off
     before its closing quote — JSX lets an attribute run on. */
 export type Token = {
-    kind: "ident" | "string" | "punct";
+    kind: "ident" | "string" | "punct" | "regex";
     value: string;
     nl?: true;
     escaped?: true;
@@ -71,8 +71,13 @@ export type Token = {
     comments and template bodies dropped. A regex literal after an
     operator is skipped — only one that closes on its line, and never the
     `/>` after a JSX attribute's `}`; JSX text is read as code, so an apostrophe in
-    prose can swallow a stretch — a false negative, never a crash. */
-export declare function tokenize(text: string): Token[];
+    prose can swallow a stretch — a false negative, never a crash.
+    `hidden`, when given, gets the code of each template's `${…}`, which
+    the tokens leave out; `ambiguous`, where a `/` right after `}` was read
+    as a regex — after an object, JavaScript reads a division there, and
+    what follows is code (`{} / f(x) / 1`). With `regexes`, a regex is a
+    token of its own rather than skipped. */
+export declare function tokenize(text: string, hidden?: string[], ambiguous?: number[], regexes?: boolean): Token[];
 export declare function routeKey(route: string): string;
 export declare function scanRepository(dir: string, opts: ScanOptions): Promise<ScanResult>;
 export type MergeResult = {

package/dist/scan.js

@@ -813,12 +813,69 @@ function unescapeAt(text, at) {
         return [String.fromCharCode(parseInt(octal[0], 8)), at + 1 + octal[0].length];
     return [e, at + 2];
 }
+/** The index of the `}` that closes the template substitution whose code
+    starts at `from`, with strings, templates and comments in it read as
+    JavaScript reads them — `${"}"}` closes at the second brace; the end of
+    the text when nothing closes it. A `/` in it that starts no comment may
+    start a regex, which can hold a brace or a quote: `doubt` hears of it. */
+function substitutionEnd(text, from, doubt) {
+    // what the scan is in: code with that many open braces, or a template's text (0), innermost last
+    const stack = [1];
+    for (let j = from; j < text.length; j++) {
+        const c = text[j];
+        const top = stack[stack.length - 1];
+        if (top === 0) {
+            if (c === "\\")
+                j++;
+            else if (c === "`")
+                stack.pop();
+            else if (c === "$" && text[j + 1] === "{") {
+                stack.push(1);
+                j++;
+            }
+        }
+        else if (c === "{")
+            stack[stack.length - 1] = top + 1;
+        else if (c === "}") {
+            if (top > 1)
+                stack[stack.length - 1] = top - 1;
+            else {
+                stack.pop();
+                if (stack.length === 0)
+                    return j;
+            }
+        }
+        else if (c === '"' || c === "'") {
+            for (j++; j < text.length && text[j] !== c && text[j] !== "\n" && text[j] !== "\r"; j++)
+                if (text[j] === "\\")
+                    j++;
+        }
+        else if (c === "`")
+            stack.push(0);
+        else if (c === "/" && text[j + 1] === "/") {
+            while (j + 1 < text.length && text[j + 1] !== "\n" && text[j + 1] !== "\r")
+                j++;
+        }
+        else if (c === "/" && text[j + 1] === "*") {
+            const end = text.indexOf("*/", j + 2);
+            j = end === -1 ? text.length : end + 1;
+        }
+        else if (c === "/")
+            doubt?.();
+    }
+    return text.length;
+}
 /** JavaScript tokens: identifiers, string literals and punctuation, with
     comments and template bodies dropped. A regex literal after an
     operator is skipped — only one that closes on its line, and never the
     `/>` after a JSX attribute's `}`; JSX text is read as code, so an apostrophe in
-    prose can swallow a stretch — a false negative, never a crash. */
-export function tokenize(text) {
+    prose can swallow a stretch — a false negative, never a crash.
+    `hidden`, when given, gets the code of each template's `${…}`, which
+    the tokens leave out; `ambiguous`, where a `/` right after `}` was read
+    as a regex — after an object, JavaScript reads a division there, and
+    what follows is code (`{} / f(x) / 1`). With `regexes`, a regex is a
+    token of its own rather than skipped. */
+export function tokenize(text, hidden, ambiguous, regexes = false) {
     const out = [];
     let i = 0;
     const n = text.length;
@@ -864,16 +921,11 @@ export function tokenize(text) {
                     continue;
                 }
                 if (c === "`" && text[j] === "$" && text[j + 1] === "{") {
-                    // a substitution: skip to its closing brace (one level)
-                    let depth = 1;
-                    j += 2;
-                    while (j < n && depth > 0) {
-                        if (text[j] === "{")
-                            depth++;
-                        else if (text[j] === "}")
-                            depth--;
-                        j++;
-                    }
+                    // a substitution: its code, to the brace that closes it as JavaScript reads it
+                    const from = j + 2;
+                    const end = substitutionEnd(text, from, ambiguous ? () => ambiguous.push(from) : undefined);
+                    hidden?.push(text.slice(from, end));
+                    j = end + 1;
                     value += "${}";
                     continue;
                 }
@@ -932,9 +984,13 @@ export function tokenize(text) {
                 }
                 // a regex closes on its own line; a `/` that doesn't is the code's
                 if (text[j] === "/") {
+                    if (prev?.kind === "punct" && prev.value === "}")
+                        ambiguous?.push(i);
                     j++;
                     while (j < n && /[a-z]/.test(text[j]))
                         j++; // flags
+                    if (regexes)
+                        push({ kind: "regex", value: text.slice(i, j) });
                     i = j;
                     continue;
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mapled/cli",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "Mapled CLI — sign in, link a project, generate TypeScript types for its content, create forms, preview drafts and check the site's integration.",
   "license": "MIT",
   "homepage": "https://mapled.io",