codeplay-common 4.10.1 → 4.10.2

package/files/buildCodeplay/codeplayBeforeBuild.js

@@ -5,12 +5,137 @@ const fs = require('fs');
 const path = require('path');
 const plist = require('plist');
 
-// Preserve comments, strings, and custom tree-shaking objects/functions.
-// Only migrate the explicit boolean opt-out used by older Codeplay configs.
-const migrateViteTreeShaking = (content) => content.replace(
-  /\/\*[\s\S]*?\*\/|\/\/[^\r\n]*|"(?:\\[\s\S]|[^"\\])*"|'(?:\\[\s\S]|[^'\\])*'|`(?:\\[\s\S]|[^`\\])*`|\btreeshake([ \t]*:[ \t]*)false\b/g,
-  (match, separator) => separator === undefined ? match : `treeshake${separator}true`
-);
+// Edit only build.rollupOptions.treeshake in the exported Vite config.
+// Keep source formatting/comments and valid custom option objects intact.
+const migrateViteTreeShaking = (content) => {
+  const newline = content.includes('\r\n') ? '\r\n' : '\n';
+  const tokens = [];
+  const pairs = new Map();
+  const stack = [];
+  const lexer = /\s+|\/\*[\s\S]*?\*\/|\/\/[^\r\n]*|"(?:\\[\s\S]|[^"\\])*"|'(?:\\[\s\S]|[^'\\])*'|`(?:\\[\s\S]|[^`\\])*`|=>|\.\.\.|[\w$]+|[^\s]/gy;
+  let match;
+  while ((match = lexer.exec(content))) {
+    const value = match[0];
+    if (/^\s|^\/\*|^\/\//.test(value)) continue;
+    // Regex literals may contain braces/commas; treat them as a single value.
+    if (value === '/' && (!tokens.length || /^(?:=|\(|\[|:|,|return|=>|!|\?|\||&)$/.test(tokens.at(-1).value))) {
+      const regex = /^\/(?:\\[^\r\n]|\[(?:\\[^\r\n]|[^\]\\\r\n])*\]|[^/\\[\r\n])+\/[a-z]*/.exec(content.slice(match.index));
+      if (!regex) throw new Error('Cannot safely read Vite regex literal; configuration preserved.');
+      lexer.lastIndex = match.index + regex[0].length;
+      tokens.push({ value: regex[0], start: match.index, end: lexer.lastIndex });
+      continue;
+    }
+    const index = tokens.length;
+    tokens.push({ value, start: match.index, end: lexer.lastIndex });
+    if (['{', '[', '('].includes(value)) stack.push(index);
+    else if (['}', ']', ')'].includes(value)) {
+      const open = stack.pop();
+      if (open === undefined || tokens[open].value !== ({ '}': '{', ']': '[', ')': '(' })[value]) {
+        throw new Error('Cannot safely read Vite configuration; file preserved.');
+      }
+      pairs.set(open, index);
+    }
+  }
+  if (stack.length) throw new Error('Unbalanced Vite configuration; file preserved.');
+  const value = index => tokens[index]?.value;
+  const edits = [];
+  const properties = open => {
+    const result = [];
+    const close = pairs.get(open);
+    for (let i = open + 1; i < close;) {
+      if (value(i) === ',') { i++; continue; }
+      const start = i;
+      let key = i;
+      if (value(i) === '[') {
+        if (pairs.get(i) !== i + 2 || !/^['"]/.test(value(i + 1))) throw new Error('Dynamic Vite property name; file preserved.');
+        key = i + 1;
+      }
+      const accessor = ['get', 'set'].includes(value(i)) && value(i + 2) === '(';
+      if (accessor) key = i + 1;
+      const name = value(key).replace(/^(['"])(.*)\1$/, '$2');
+      const afterKey = value(start) === '[' ? pairs.get(start) + 1 : key + 1;
+      const colon = value(afterKey) === ':';
+      while (i < close && value(i) !== ',') i = pairs.has(i) ? pairs.get(i) + 1 : i + 1;
+      if (colon || (key === start && i === start + 1) || value(afterKey) === '(') {
+        result.push({ name, start, first: colon ? afterKey + 1 : start, end: i, comma: value(i) === ',', colon });
+      }
+    }
+    return result;
+  };
+  const findConfig = (index, visited = new Set()) => {
+    if (visited.has(index)) throw new Error('Circular Vite configuration reference; file preserved.');
+    visited.add(index);
+    if (value(index) === 'async') return findConfig(index + 1, visited);
+    if (value(index) === '(') {
+      const close = pairs.get(index);
+      if (value(close + 1) === '=>') return findBody(close + 2, visited);
+      return findConfig(index + 1, visited);
+    }
+    if (value(index + 1) === '=>') return findBody(index + 2, visited);
+    if (value(index) === 'function') {
+      let body = index + 1;
+      while (body < tokens.length && value(body) !== '{') body++;
+      return findBody(body, visited);
+    }
+    if (value(index) === '{') return index;
+    if (value(index + 1) === '(') return findConfig(index + 2, visited);
+    const declaration = tokens.findIndex((token, i) => ['const', 'let', 'var'].includes(token.value) && value(i + 1) === value(index) && value(i + 2) === '=');
+    if (declaration >= 0) return findConfig(declaration + 3, visited);
+    throw new Error('Unsupported dynamic Vite config; cannot safely set treeshake. File preserved.');
+  };
+  const findBody = (index, visited) => {
+    if (value(index) !== '{') return findConfig(index, visited);
+    const returns = [];
+    for (let i = index + 1; i < pairs.get(index); i++) {
+      if (value(i) === 'return') returns.push(i + 1);
+      if (pairs.has(i)) i = pairs.get(i);
+    }
+    if (returns.length !== 1) throw new Error('Vite config must return one static object for automatic treeshake migration. File preserved.');
+    return findConfig(returns[0], visited);
+  };
+  const append = (open, property) => {
+    const close = pairs.get(open);
+    const last = tokens[close - 1];
+    const line = content.slice(content.lastIndexOf('\n', tokens[open].start) + 1, tokens[open].start);
+    const indent = line.match(/^[ \t]*/)[0];
+    const needsComma = close > open + 1 && last.value !== ',';
+    const inlineComma = needsComma && last.end === tokens[close].start;
+    if (needsComma && !inlineComma) edits.push({ start: last.end, end: last.end, text: ',' });
+    edits.push({ start: tokens[close].start, end: tokens[close].start, text: `${inlineComma ? ',' : ''}${newline}${indent}  ${property},${newline}${indent}` });
+  };
+  let exported = tokens.findIndex((token, i) => token.value === 'export' && value(i + 1) === 'default');
+  if (exported >= 0) exported += 2;
+  else {
+    exported = tokens.findIndex((token, i) => token.value === 'module' && value(i + 1) === '.' && value(i + 2) === 'exports' && value(i + 3) === '=');
+    if (exported >= 0) exported += 4;
+  }
+  if (exported < 0) throw new Error('No supported Vite config export found; file preserved.');
+  const config = findConfig(exported);
+  const build = properties(config).filter(property => property.name === 'build').at(-1);
+  if (!build) append(config, 'build: { rollupOptions: { treeshake: true } }');
+  else {
+    if (value(build.first) !== '{' || pairs.get(build.first) !== build.end - 1) throw new Error('Dynamic Vite build settings; file preserved.');
+    const rollup = properties(build.first).filter(property => property.name === 'rollupOptions').at(-1);
+    if (!rollup) append(build.first, 'rollupOptions: { treeshake: true }');
+    else {
+      if (value(rollup.first) !== '{' || pairs.get(rollup.first) !== rollup.end - 1) throw new Error('Dynamic Vite rollupOptions; file preserved.');
+      const entries = properties(rollup.first).filter(property => property.name === 'treeshake');
+      if (!entries.length) append(rollup.first, 'treeshake: true');
+      else {
+        // JavaScript uses the last duplicate; retain that setting and remove earlier ones.
+        const keep = entries.at(-1);
+        for (const entry of entries.slice(0, -1)) {
+          edits.push({ start: tokens[entry.start].start, end: entry.comma ? tokens[entry.end].end : tokens[entry.end - 1].end, text: '' });
+        }
+        const isTrue = value(keep.first) === 'true' && keep.end === keep.first + 1;
+        const isObject = value(keep.first) === '{' && pairs.get(keep.first) === keep.end - 1;
+        if (!isTrue && !isObject) edits.push({ start: tokens[keep.first].start, end: tokens[keep.end - 1].end, text: keep.colon ? 'true' : 'treeshake: true' });
+      }
+    }
+  }
+  for (const edit of edits.sort((a, b) => b.start - a.start)) content = content.slice(0, edit.start) + edit.text + content.slice(edit.end);
+  return content;
+};
 
 
 
@@ -2952,7 +3077,7 @@ const syncViteTreeShaking = () => {
   const next = migrateViteTreeShaking(current);
   if (next !== current) {
     fs.writeFileSync(configPath, next, 'utf8');
-    console.log('✅ Enabled Vite tree shaking for common JavaScript and other unused exports.');
+    console.log('✅ Vite treeshake setting updated without duplicate entries.');
   }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeplay-common",
-  "version": "4.10.1",
+  "version": "4.10.2",
   "description": "Common build scripts and files",
   "scripts": {
     "postinstall": "node scripts/sync-files.js",