@ttsc/playground 0.19.3 → 0.20.0

package/README.md

@@ -127,6 +127,8 @@ The typia pack itself is built by the site (typically with a `pack-typia-sources
 
 When the user types `import {v4} from "uuid"`, the shell auto-fetches `uuid` (and its transitive deps) from the npm registry, unpacks the tgz in the browser, and mounts the files into the wasm MemFS, no proxy server needed.
 
+Discovery covers static quoted specifiers in imports, exports, dynamic imports, `require(...)`, and direct `require?.(...)` calls, using their cooked JavaScript string values while ignoring comments, regular expressions, template quasis, and computed arguments.
+
 ```ts
 import {
   collectExternalPackageNames,
@@ -140,6 +142,10 @@ const installed = await installPlaygroundDependencies(names, {
 // mount installed.compilerFiles into the wasm MemFS via service.installDependencies
 ```
 
+For an additive edit, pass the prior call's `resolvedDependencies` as `installedDependencies`; the installer validates every new range against the mounted registry identity and exact version, and it returns only newly downloaded tarballs in `packages` plus the complete updated exact state in `resolvedDependencies`.
+
+When a direct source import is removed, solve the complete current root list without `installedDependencies` and atomically replace the compiler, editor, and runtime file maps so files from the obsolete graph cannot survive.
+
 `PlaygroundShell` wires this automatically on every keystroke, debounced 900 ms, with an abort signal on source change.
 
 ## Tailwind setup

package/lib/src/npm/collectExternalPackageNames.js

@@ -20,7 +20,7 @@ function collectExternalPackageNames(source, ignoredPackages = BUILT_IN_PLAYGROU
 /**
  * Collect the string specifiers of every executable module-loading construct in
  * `source`: `import`/`export ... from`, side-effect `import "x"`, dynamic
- * `import("x")`, and `require("x")` calls.
+ * `import("x")`, `require("x")`, and `require?.("x")` calls.
  *
  * The scan tokenizes `source` first so import/export/require lookalikes that
  * live inside comments, string or template contents, or regular-expression
@@ -34,7 +34,10 @@ function collectModuleSpecifiers(source) {
     const out = [];
     const asString = (token) => token && token.kind === "string" ? token.value : null;
     const isOpenParen = (token) => token !== undefined && token.kind === "punct" && token.value === "(";
-    const isMemberAccess = (token) => token !== undefined && token.kind === "punct" && token.value === ".";
+    const isMemberAccess = (token) => token !== undefined &&
+        token.kind === "punct" &&
+        (token.value === "." || token.value === "?.");
+    const isOptionalChain = (token) => token !== undefined && token.kind === "punct" && token.value === "?.";
     for (let i = 0; i < tokens.length; i++) {
         const token = tokens[i];
         if (!token || token.kind !== "word")
@@ -43,8 +46,9 @@ function collectModuleSpecifiers(source) {
             // `obj.require(...)` is an unrelated method call, not CommonJS require.
             if (isMemberAccess(tokens[i - 1]))
                 continue;
-            if (isOpenParen(tokens[i + 1])) {
-                const spec = asString(tokens[i + 2]);
+            const optional = isOptionalChain(tokens[i + 1]) && isOpenParen(tokens[i + 2]);
+            if (isOpenParen(tokens[i + 1]) || optional) {
+                const spec = asString(tokens[i + (optional ? 3 : 2)]);
                 if (spec !== null)
                     out.push(spec);
             }
@@ -114,11 +118,159 @@ const REGEX_PRECEDING_KEYWORDS = new Set([
     "void",
     "do",
     "else",
+    "extends",
     "yield",
     "await",
     "case",
     "throw",
 ]);
+const CONTROL_HEADER_KEYWORDS = new Set([
+    "if",
+    "while",
+    "for",
+    "with",
+    "switch",
+    "catch",
+]);
+const BLOCK_PRECEDING_KEYWORDS = new Set(["else", "try", "finally", "do"]);
+/**
+ * Retain just enough delimiter context to distinguish a regex statement after a
+ * control header or block from division after an expression value. The
+ * collector is not a parser: this state only decides whether a following slash
+ * is opaque regex text or executable code worth scanning for module calls.
+ */
+class LexicalContext {
+    tokens = [];
+    parens = [];
+    braces = [];
+    pendingFunctionExpression;
+    pendingClassExpressions = [];
+    isRegexAllowed() {
+        return isRegexAllowedAfter(this.tokens[this.tokens.length - 1]);
+    }
+    pushWord(value) {
+        if (value === "function" &&
+            !isMemberAccess(this.tokens[this.tokens.length - 1]))
+            this.pendingFunctionExpression = isExpressionPosition(this.tokens);
+        else if (value === "class" &&
+            !isMemberAccess(this.tokens[this.tokens.length - 1]))
+            this.pendingClassExpressions.push(isExpressionPosition(this.tokens));
+        this.tokens.push({ kind: "word", value });
+    }
+    pushOther() {
+        this.tokens.push({ kind: "other" });
+    }
+    pushPunct(value) {
+        if (value === ":") {
+            const previous = this.tokens[this.tokens.length - 1];
+            if (previous?.kind === "word" &&
+                !isMemberAccess(this.tokens[this.tokens.length - 2])) {
+                if (previous.value === "function")
+                    this.pendingFunctionExpression = undefined;
+                else if (previous.value === "class")
+                    this.pendingClassExpressions.pop();
+            }
+        }
+        if (value === "(") {
+            const functionIsExpression = this.pendingFunctionExpression;
+            this.pendingFunctionExpression = undefined;
+            this.parens.push(functionIsExpression === undefined
+                ? {
+                    kind: isControlHeader(this.tokens) ? "control" : "normal",
+                }
+                : { kind: "function", functionIsExpression });
+            this.tokens.push({ kind: "punct", value });
+            return;
+        }
+        if (value === ")") {
+            const context = this.parens.pop();
+            this.tokens.push({
+                kind: "punct",
+                value,
+                regexAllowedAfter: context?.kind === "control",
+                functionBodyIsExpression: context?.kind === "function"
+                    ? context.functionIsExpression
+                    : undefined,
+            });
+            return;
+        }
+        if (value === "{") {
+            this.braces.push(this.braceAllowsRegexAfter());
+            this.tokens.push({ kind: "punct", value });
+            return;
+        }
+        if (value === "}") {
+            this.tokens.push({
+                kind: "punct",
+                value,
+                regexAllowedAfter: this.braces.pop() ?? false,
+            });
+            return;
+        }
+        this.tokens.push({ kind: "punct", value });
+    }
+    braceAllowsRegexAfter() {
+        const previous = this.tokens[this.tokens.length - 1];
+        if (previous?.kind === "punct" &&
+            previous.value === ")" &&
+            previous.functionBodyIsExpression !== undefined)
+            return !previous.functionBodyIsExpression;
+        if (this.classBodyPrecedes(previous))
+            return !this.pendingClassExpressions.pop();
+        if (!previous)
+            return true;
+        if (previous.kind === "word")
+            return BLOCK_PRECEDING_KEYWORDS.has(previous.value);
+        if (previous.kind !== "punct")
+            return false;
+        if (previous.value === ")")
+            return previous.regexAllowedAfter === true;
+        return (previous.value === ";" || previous.value === "{" || previous.value === "}");
+    }
+    classBodyPrecedes(previous) {
+        if (this.pendingClassExpressions.length === 0 || this.parens.length !== 0)
+            return false;
+        if (!previous)
+            return false;
+        if (previous.kind === "word" || previous.kind === "other")
+            return true;
+        return (previous.kind === "punct" &&
+            (previous.value === ")" ||
+                previous.value === "]" ||
+                previous.value === "}"));
+    }
+}
+function isControlHeader(tokens) {
+    const previous = tokens[tokens.length - 1];
+    const beforePrevious = tokens[tokens.length - 2];
+    if (previous?.kind === "word" &&
+        CONTROL_HEADER_KEYWORDS.has(previous.value) &&
+        !isMemberAccess(beforePrevious))
+        return true;
+    return (previous?.kind === "word" &&
+        previous.value === "await" &&
+        beforePrevious?.kind === "word" &&
+        beforePrevious.value === "for");
+}
+function isMemberAccess(token) {
+    return (token?.kind === "punct" && (token.value === "." || token.value === "?."));
+}
+function isExpressionPosition(tokens) {
+    let index = tokens.length - 1;
+    // `async function` inherits the context before `async`: it is a declaration
+    // at a statement boundary and an expression after an assignment or return.
+    const latest = tokens[index];
+    if (latest?.kind === "word" && latest.value === "async")
+        index--;
+    const previous = tokens[index];
+    if (!previous)
+        return false;
+    if (previous.kind === "word")
+        return REGEX_PRECEDING_KEYWORDS.has(previous.value);
+    if (previous.kind !== "punct")
+        return false;
+    return ![")", "]", "}", ";", "{", "++", "--"].includes(previous.value);
+}
 /**
  * Lexically tokenize `source` into the coarse token stream the specifier
  * collector needs. Comments are dropped; strings, templates, regex literals,
@@ -126,23 +278,14 @@ const REGEX_PRECEDING_KEYWORDS = new Set([
  * grammar match.
  */
 function tokenize(source) {
-    const tokens = [];
+    const context = new LexicalContext();
+    const tokens = context.tokens;
     const n = source.length;
     const isIdStart = (c) => (c >= "a" && c <= "z") || (c >= "A" && c <= "Z") || c === "_" || c === "$";
     const isIdPart = (c) => isIdStart(c) || (c >= "0" && c <= "9");
     const isDigit = (c) => c >= "0" && c <= "9";
     // A `/` opens a regex only in operator/statement position — never right after
     // a value (identifier, number, string, template, regex, `)` or `]`).
-    const regexAllowed = () => {
-        const prev = tokens[tokens.length - 1];
-        if (!prev)
-            return true;
-        if (prev.kind === "string" || prev.kind === "other")
-            return false;
-        if (prev.kind === "word")
-            return REGEX_PRECEDING_KEYWORDS.has(prev.value);
-        return prev.value !== ")" && prev.value !== "]";
-    };
     let i = 0;
     while (i < n) {
         const c = source[i];
@@ -172,83 +315,47 @@ function tokenize(source) {
             continue;
         }
         // Regular-expression literal.
-        if (c === "/" && regexAllowed()) {
-            i++;
-            let inClass = false;
-            while (i < n) {
-                const d = source[i];
-                if (d === "\\") {
-                    i += 2;
-                    continue;
-                }
-                if (d === "\n")
-                    break;
-                if (d === "[")
-                    inClass = true;
-                else if (d === "]")
-                    inClass = false;
-                else if (d === "/" && !inClass) {
-                    i++;
-                    break;
-                }
-                i++;
-            }
-            while (i < n && isIdPart(source[i]))
-                i++; // flags
-            tokens.push({ kind: "other" });
+        if (c === "/" && context.isRegexAllowed()) {
+            i = skipRegularExpression(source, i, isIdPart);
+            context.pushOther();
             continue;
         }
         // String literal.
         if (c === '"' || c === "'") {
-            i++;
-            let value = "";
-            while (i < n) {
-                const d = source[i];
-                if (d === "\\") {
-                    value += source[i + 1] ?? "";
-                    i += 2;
-                    continue;
-                }
-                if (d === c) {
-                    i++;
-                    break;
-                }
-                if (d === "\n")
-                    break; // unterminated single-line string
-                value += d;
-                i++;
-            }
-            tokens.push({ kind: "string", value });
+            const quoted = readQuotedString(source, i, c);
+            i = quoted.end;
+            if (quoted.value === null)
+                context.pushOther();
+            else
+                tokens.push({ kind: "string", value: quoted.value });
             continue;
         }
-        // Template literal. Contents (including `${...}` expressions) are treated as
-        // opaque: a template specifier is not statically resolvable.
+        // Template quasis are opaque, but `${...}` substitutions are executable
+        // JavaScript and must receive the same lexical treatment as top-level code.
         if (c === "`") {
             i++;
-            let depth = 0;
             while (i < n) {
                 const d = source[i];
                 if (d === "\\") {
                     i += 2;
                     continue;
                 }
-                if (depth === 0 && d === "`") {
+                if (d === "`") {
                     i++;
                     break;
                 }
                 if (d === "$" && source[i + 1] === "{") {
-                    depth++;
-                    i += 2;
-                    continue;
-                }
-                if (depth > 0 && d === "}") {
-                    depth--;
-                    i++;
+                    const start = i + 2;
+                    const end = findTemplateSubstitutionEnd(source, start);
+                    context.pushOther();
+                    tokens.push(...tokenize(source.slice(start, end)));
+                    context.pushOther();
+                    i = end < n ? end + 1 : end;
                     continue;
                 }
                 i++;
             }
-            tokens.push({ kind: "other" });
+            context.pushOther();
             continue;
         }
         // Identifier / keyword.
@@ -256,7 +363,7 @@ function tokenize(source) {
             let j = i + 1;
             while (j < n && isIdPart(source[j]))
                 j++;
-            tokens.push({ kind: "word", value: source.slice(i, j) });
+            context.pushWord(source.slice(i, j));
             i = j;
             continue;
         }
@@ -265,14 +372,270 @@ function tokenize(source) {
             let j = i + 1;
             while (j < n && /[0-9a-fA-FxXoObBeE._]/.test(source[j]))
                 j++;
-            tokens.push({ kind: "other" });
+            context.pushOther();
             i = j;
             continue;
         }
+        // Compound punctuation whose identity affects the following slash or
+        // direct optional-call recognition.
+        if ((c === "+" || c === "-") && source[i + 1] === c) {
+            context.pushPunct(c + c);
+            i += 2;
+            continue;
+        }
+        if (c === "?" && source[i + 1] === "." && !isDigit(source[i + 2] ?? "")) {
+            context.pushPunct("?.");
+            i += 2;
+            continue;
+        }
         // Single punctuation character.
-        tokens.push({ kind: "punct", value: c });
+        context.pushPunct(c);
         i++;
     }
     return tokens;
 }
+function findTemplateSubstitutionEnd(source, start) {
+    let depth = 1;
+    const context = new LexicalContext();
+    const isIdentifierStart = (character) => /[A-Za-z_$]/.test(character);
+    const isIdentifierPart = (character) => /[A-Za-z0-9_$]/.test(character);
+    for (let i = start; i < source.length; i++) {
+        const c = source[i];
+        if (/\s/.test(c))
+            continue;
+        if (c === "\\") {
+            i++;
+            continue;
+        }
+        if (c === "'" || c === '"') {
+            i = skipQuoted(source, i, c);
+            context.tokens.push({ kind: "string", value: "" });
+            continue;
+        }
+        if (c === "`") {
+            i = skipTemplate(source, i);
+            context.pushOther();
+            continue;
+        }
+        if (c === "/" && source[i + 1] === "/") {
+            i += 2;
+            while (i < source.length && source[i] !== "\n")
+                i++;
+            continue;
+        }
+        if (c === "/" && source[i + 1] === "*") {
+            i += 2;
+            while (i < source.length && !(source[i] === "*" && source[i + 1] === "/"))
+                i++;
+            i++;
+            continue;
+        }
+        if (c === "/" && context.isRegexAllowed()) {
+            i = skipRegularExpression(source, i, (character) => /[A-Za-z0-9_$]/.test(character));
+            i--;
+            context.pushOther();
+            continue;
+        }
+        if (isIdentifierStart(c)) {
+            let end = i + 1;
+            while (end < source.length && isIdentifierPart(source[end]))
+                end++;
+            context.pushWord(source.slice(i, end));
+            i = end - 1;
+            continue;
+        }
+        if (c >= "0" && c <= "9") {
+            let end = i + 1;
+            while (end < source.length && /[0-9a-fA-FxXoObBeE._]/.test(source[end]))
+                end++;
+            context.pushOther();
+            i = end - 1;
+            continue;
+        }
+        if ((c === "+" || c === "-") && source[i + 1] === c) {
+            context.pushPunct(c + c);
+            i++;
+            continue;
+        }
+        if (c === "?" &&
+            source[i + 1] === "." &&
+            !/[0-9]/.test(source[i + 2] ?? "")) {
+            context.pushPunct("?.");
+            i++;
+            continue;
+        }
+        if (c === "{")
+            depth++;
+        else if (c === "}" && --depth === 0)
+            return i;
+        context.pushPunct(c);
+    }
+    return source.length;
+}
+function isRegexAllowedAfter(previous) {
+    if (!previous)
+        return true;
+    if (previous.kind === "string" || previous.kind === "other")
+        return false;
+    if (previous.kind === "word")
+        return REGEX_PRECEDING_KEYWORDS.has(previous.value);
+    if (previous.value === ")" || previous.value === "}")
+        return previous.regexAllowedAfter === true;
+    return (previous.value !== "]" && previous.value !== "++" && previous.value !== "--");
+}
+/** Read one quoted literal and compute its JavaScript StringValue. */
+function readQuotedString(source, start, quote) {
+    let value = "";
+    for (let index = start + 1; index < source.length;) {
+        const character = source[index];
+        if (character === quote) {
+            return { end: index + 1, value };
+        }
+        if (isLineTerminator(character)) {
+            return { end: index, value: null };
+        }
+        if (character !== "\\") {
+            value += character;
+            index++;
+            continue;
+        }
+        const escaped = source[index + 1];
+        if (escaped === undefined) {
+            return { end: source.length, value: null };
+        }
+        if (isLineTerminator(escaped)) {
+            index += escaped === "\r" && source[index + 2] === "\n" ? 3 : 2;
+            continue;
+        }
+        const simple = SIMPLE_STRING_ESCAPES[escaped];
+        if (simple !== undefined) {
+            value += simple;
+            index += 2;
+            continue;
+        }
+        if (escaped === "0") {
+            if (/[0-9]/.test(source[index + 2] ?? "")) {
+                return invalidQuotedString(source, start, quote);
+            }
+            value += "\0";
+            index += 2;
+            continue;
+        }
+        if (escaped >= "1" && escaped <= "9") {
+            return invalidQuotedString(source, start, quote);
+        }
+        if (escaped === "x") {
+            const digits = source.slice(index + 2, index + 4);
+            if (digits.length !== 2 || !/^[0-9a-fA-F]{2}$/.test(digits)) {
+                return invalidQuotedString(source, start, quote);
+            }
+            value += String.fromCharCode(Number.parseInt(digits, 16));
+            index += 4;
+            continue;
+        }
+        if (escaped === "u") {
+            if (source[index + 2] === "{") {
+                const close = source.indexOf("}", index + 3);
+                const digits = close < 0 ? "" : source.slice(index + 3, close);
+                const significantDigits = digits.replace(/^0+/, "") || "0";
+                const codePoint = Number.parseInt(digits, 16);
+                if (close < 0 ||
+                    !/^[0-9a-fA-F]+$/.test(digits) ||
+                    significantDigits.length > 6 ||
+                    codePoint > 0x10ffff) {
+                    return invalidQuotedString(source, start, quote);
+                }
+                value += String.fromCodePoint(codePoint);
+                index = close + 1;
+                continue;
+            }
+            const digits = source.slice(index + 2, index + 6);
+            if (digits.length !== 4 || !/^[0-9a-fA-F]{4}$/.test(digits)) {
+                return invalidQuotedString(source, start, quote);
+            }
+            value += String.fromCharCode(Number.parseInt(digits, 16));
+            index += 6;
+            continue;
+        }
+        // IdentityEscape / NonEscapeCharacter: the slash is discarded and the
+        // escaped source character contributes directly to the StringValue.
+        value += escaped;
+        index += 2;
+    }
+    return { end: source.length, value: null };
+}
+const SIMPLE_STRING_ESCAPES = {
+    "'": "'",
+    '"': '"',
+    "\\": "\\",
+    b: "\b",
+    f: "\f",
+    n: "\n",
+    r: "\r",
+    t: "\t",
+    v: "\v",
+};
+function invalidQuotedString(source, start, quote) {
+    const end = skipQuoted(source, start, quote);
+    return {
+        end: end < source.length && source[end] === quote ? end + 1 : end,
+        value: null,
+    };
+}
+function isLineTerminator(character) {
+    return (character === "\n" ||
+        character === "\r" ||
+        character === "\u2028" ||
+        character === "\u2029");
+}
+function skipRegularExpression(source, start, isIdentifierPart) {
+    let index = start + 1;
+    let inClass = false;
+    while (index < source.length) {
+        const character = source[index];
+        if (character === "\\") {
+            index += 2;
+            continue;
+        }
+        if (character === "\n")
+            break;
+        if (character === "[")
+            inClass = true;
+        else if (character === "]")
+            inClass = false;
+        else if (character === "/" && !inClass) {
+            index++;
+            break;
+        }
+        index++;
+    }
+    while (index < source.length && isIdentifierPart(source[index]))
+        index++;
+    return index;
+}
+function skipQuoted(source, start, quote) {
+    for (let i = start + 1; i < source.length; i++) {
+        if (source[i] === "\\") {
+            i++;
+            continue;
+        }
+        if (source[i] === quote || isLineTerminator(source[i]))
+            return i;
+    }
+    return source.length;
+}
+function skipTemplate(source, start) {
+    for (let i = start + 1; i < source.length; i++) {
+        if (source[i] === "\\") {
+            i++;
+            continue;
+        }
+        if (source[i] === "`")
+            return i;
+        if (source[i] === "$" && source[i + 1] === "{") {
+            i = findTemplateSubstitutionEnd(source, i + 2);
+        }
+    }
+    return source.length;
+}
 //# sourceMappingURL=collectExternalPackageNames.js.map