@mapled/cli 0.10.0 → 0.12.0

package/dist/scan.js

@@ -1,7 +1,7 @@
 import { createRequire } from "node:module";
 import { readdir, readFile } from "node:fs/promises";
 import path from "node:path";
-import { targetFor } from "./manifest.js";
+import { sameCapabilities, targetFor } from "./manifest.js";
 const SKIP_DIRS = new Set([
     "node_modules",
     ".git",
@@ -33,7 +33,7 @@ export function loadTypeScript(dir) {
         return null;
     }
 }
-async function listFiles(dir, max) {
+export async function listFiles(dir, max) {
     const files = [];
     let truncated = false;
     const walk = async (rel) => {
@@ -73,7 +73,7 @@ async function listFiles(dir, max) {
 const PAGE_EXT = /\.(tsx|jsx|ts|js|mjs|mdx|md|astro|svelte|vue)$/;
 /** Next.js App Router segments: groups and slots vanish, params keep
     the [param] form the manifest uses. */
-function appRoute(segments) {
+export function appRoute(segments) {
     const kept = [];
     for (const s of segments) {
         if (s.startsWith("_"))
@@ -753,18 +753,88 @@ function scopeOf(ts, id) {
     }
     return id.getSourceFile();
 }
+// what JavaScript reads as an identifier: Unicode letters and digits, `$`, `_`, and the two joiners inside one
+const ID_START = /^[\p{ID_Start}$_]$/u;
+const ID_PART = /^[\p{ID_Continue}$\p{Join_Control}]$/u;
+/** The identifier character at `at` as JavaScript reads it — itself, or a
+    `\u` escape that reads as one — and the index after it; null when none
+    is there. */
+function identCharAt(text, at, start) {
+    const c = text.charCodeAt(at);
+    if (Number.isNaN(c))
+        return null;
+    const test = start ? ID_START : ID_PART;
+    if (c === 92) {
+        if (text[at + 1] !== "u")
+            return null;
+        const [read, next] = unescapeAt(text, at);
+        // `\u` without its hex digits is no escape
+        return next > at + 2 && test.test(read) ? [read, next] : null;
+    }
+    // ASCII by its code: letters, `$`, `_`, and digits after the first
+    if (c < 128)
+        return (c >= 97 && c <= 122) || (c >= 65 && c <= 90) || c === 36 || c === 95 || (!start && c >= 48 && c <= 57) ? [text[at], at + 1] : null;
+    const ch = String.fromCodePoint(text.codePointAt(at));
+    return test.test(ch) ? [ch, at + ch.length] : null;
+}
+// `\n`, `\t` … by the letter, as character codes
+const SIMPLE_ESCAPES = { n: 10, r: 13, t: 9, b: 8, f: 12, v: 11 };
+/** The escape at `at` (a backslash) as JavaScript reads it in a string —
+    `\x6c`, `l`, `\u{6c}`, `\154`, `\n`, a line continuation, any other
+    character as itself — and the index after it. */
+function unescapeAt(text, at) {
+    const e = text[at + 1];
+    if (e === undefined)
+        return ["", at + 1];
+    const simple = SIMPLE_ESCAPES[e];
+    if (simple !== undefined)
+        return [String.fromCharCode(simple), at + 2];
+    const code = e.charCodeAt(0);
+    // a line continuation: the backslash and the line break read as nothing
+    if (e === "\r")
+        return ["", text[at + 2] === "\n" ? at + 3 : at + 2];
+    if (e === "\n" || code === 0x2028 || code === 0x2029)
+        return ["", at + 2];
+    if (e === "x" && /^[\da-f]{2}$/i.test(text.slice(at + 2, at + 4)))
+        return [String.fromCharCode(parseInt(text.slice(at + 2, at + 4), 16)), at + 4];
+    if (e === "u") {
+        if (text[at + 2] === "{") {
+            const close = text.indexOf("}", at + 3);
+            const hex = close === -1 ? "" : text.slice(at + 3, close);
+            if (/^[\da-f]{1,6}$/i.test(hex) && parseInt(hex, 16) <= 0x10ffff)
+                return [String.fromCodePoint(parseInt(hex, 16)), close + 1];
+        }
+        else if (/^[\da-f]{4}$/i.test(text.slice(at + 2, at + 6)))
+            return [String.fromCharCode(parseInt(text.slice(at + 2, at + 6), 16)), at + 6];
+    }
+    // a legacy octal escape: up to three digits, the value under 256
+    const octal = /^[0-3][0-7]{0,2}|^[4-7][0-7]?/.exec(text.slice(at + 1, at + 4));
+    if (octal)
+        return [String.fromCharCode(parseInt(octal[0], 8)), at + 1 + octal[0].length];
+    return [e, at + 2];
+}
 /** JavaScript tokens: identifiers, string literals and punctuation, with
     comments and template bodies dropped. A regex literal after an
-    operator is skipped; JSX text is read as code, so an apostrophe in
+    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) {
     const out = [];
     let i = 0;
     const n = text.length;
     const REGEX_BEFORE = new Set(["(", ",", "=", ":", "[", "!", "&", "|", "?", "{", "}", ";", "return", "typeof", "=>"]);
+    let nl = false;
+    const push = (token) => {
+        if (nl)
+            token.nl = true;
+        nl = false;
+        out.push(token);
+    };
     while (i < n) {
         const c = text[i];
         if (c === " " || c === "\t" || c === "\n" || c === "\r") {
+            if (c === "\n" || c === "\r")
+                nl = true;
             i++;
             continue;
         }
@@ -775,16 +845,22 @@ export function tokenize(text) {
         }
         if (c === "/" && text[i + 1] === "*") {
             const end = text.indexOf("*/", i + 2);
+            // a comment across lines is a line break
+            if (/[\n\r]/.test(text.slice(i + 2, end === -1 ? n : end)))
+                nl = true;
             i = end === -1 ? n : end + 2;
             continue;
         }
         if (c === '"' || c === "'" || c === "`") {
             let j = i + 1;
             let value = "";
+            let escaped = false;
             while (j < n && text[j] !== c) {
                 if (text[j] === "\\") {
-                    value += text[j + 1] ?? "";
-                    j += 2;
+                    const [read, next] = unescapeAt(text, j);
+                    value += read;
+                    j = next;
+                    escaped = true;
                     continue;
                 }
                 if (c === "`" && text[j] === "$" && text[j + 1] === "{") {
@@ -801,29 +877,51 @@ export function tokenize(text) {
                     value += "${}";
                     continue;
                 }
-                if (c !== "`" && text[j] === "\n")
+                if (c !== "`" && (text[j] === "\n" || text[j] === "\r"))
                     break;
                 value += text[j];
                 j++;
             }
-            out.push({ kind: "string", value: c === "`" && value.includes("${}") ? "${}" : value });
+            const token = { kind: "string", value: c === "`" && value.includes("${}") ? "${}" : value };
+            if (escaped)
+                token.escaped = true;
+            push(token);
+            // cut off by a line break: the break stays the next token's
+            if (text[j] !== c) {
+                token.unclosed = true;
+                i = j;
+                continue;
+            }
             i = j + 1;
             continue;
         }
-        if (/[A-Za-z_$]/.test(c)) {
-            let j = i + 1;
-            while (j < n && /[A-Za-z0-9_$]/.test(text[j]))
-                j++;
-            out.push({ kind: "ident", value: text.slice(i, j) });
+        // an identifier, escapes decoded: `end\u0070oint` is `endpoint`
+        const first = identCharAt(text, i, true);
+        if (first) {
+            let value = first[0];
+            let escaped = c === "\\";
+            let j = first[1];
+            for (let part = identCharAt(text, j, false); part; part = identCharAt(text, j, false)) {
+                if (text[j] === "\\")
+                    escaped = true;
+                value += part[0];
+                j = part[1];
+            }
+            const token = { kind: "ident", value };
+            if (escaped)
+                token.escaped = true;
+            push(token);
             i = j;
             continue;
         }
         if (c === "/") {
             const prev = out[out.length - 1];
-            if (!prev || (prev.kind === "punct" && REGEX_BEFORE.has(prev.value)) || (prev.kind === "ident" && REGEX_BEFORE.has(prev.value))) {
+            // `/>` after `}` closes a JSX element whose last attribute is an expression
+            const selfClosing = prev?.kind === "punct" && prev.value === "}" && text[i + 1] === ">";
+            if (!selfClosing && (!prev || (prev.kind === "punct" && REGEX_BEFORE.has(prev.value)) || (prev.kind === "ident" && REGEX_BEFORE.has(prev.value)))) {
                 let j = i + 1;
                 let inClass = false;
-                while (j < n && (inClass || text[j] !== "/") && text[j] !== "\n") {
+                while (j < n && (inClass || text[j] !== "/") && text[j] !== "\n" && text[j] !== "\r") {
                     if (text[j] === "\\")
                         j++;
                     else if (text[j] === "[")
@@ -832,19 +930,22 @@ export function tokenize(text) {
                         inClass = false;
                     j++;
                 }
-                j++;
-                while (j < n && /[a-z]/.test(text[j]))
-                    j++; // flags
-                i = j;
-                continue;
+                // a regex closes on its own line; a `/` that doesn't is the code's
+                if (text[j] === "/") {
+                    j++;
+                    while (j < n && /[a-z]/.test(text[j]))
+                        j++; // flags
+                    i = j;
+                    continue;
+                }
             }
         }
         if (c === "=" && text[i + 1] === ">") {
-            out.push({ kind: "punct", value: "=>" });
+            push({ kind: "punct", value: "=>" });
             i += 2;
             continue;
         }
-        out.push({ kind: "punct", value: c });
+        push({ kind: "punct", value: c });
         i++;
     }
     return out;
@@ -1293,6 +1394,8 @@ export function mergeManifest(existing, scan, opts) {
         pages: scan.pages,
         bindings: out,
         ...(existing?.notes && existing.notes.length > 0 ? { notes: existing.notes } : {}),
+        ...(scan.capabilities ? { capabilities: scan.capabilities } : existing?.capabilities ? { capabilities: existing.capabilities } : {}),
     };
-    return { manifest, added, changed, unchanged, kept, dropped };
+    const capabilitiesChanged = existing !== null && !sameCapabilities(existing.capabilities, manifest.capabilities);
+    return { manifest, added, changed, unchanged, kept, dropped, capabilitiesChanged };
 }

package/dist/schema.d.ts

@@ -41,6 +41,9 @@ export type SchemaField = {
         accepts it under these too until they are removed. Not part of the
         schema hash — a rename changes the key, which is. */
     aliases?: string[];
+    /** Translated (§28.2): the field holds a value per language; the site
+        reads the default language's. Absent on older servers. */
+    localized?: boolean;
 };
 export type SchemaCollection = {
     key: string;

package/dist/schema.js

@@ -31,6 +31,8 @@ export function schemaHash(schema) {
                 : null,
             // present only for computed fields, so schemas without formulas hash as before
             ...(f.type === "computed" && f.computed ? { computed: { expression: f.computed.expression, resultType: f.computed.resultType } } : {}),
+            // present only for translated fields, so schemas without translations hash as before
+            ...(f.localized === true ? { localized: true } : {}),
         })),
     }));
     return createHash("sha256").update(JSON.stringify(projection)).digest("hex").slice(0, 12);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mapled/cli",
-  "version": "0.10.0",
-  "description": "Mapled CLI — sign in, link a project, generate TypeScript types for its content, create forms and check the site's integration.",
+  "version": "0.12.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",
   "keywords": [