@gomeniucivan/ui 1.0.54 → 1.0.55

package/loader.js

@@ -23,13 +23,10 @@
  *   use: [{ loader: require.resolve('@gomeniucivan/ui/loader'), options: { rootDir: __dirname } }],
  */
 
-'use strict';
-
-const nodePath = require('path');
-
-/** Functions whose calls get a `{ path }` second argument injected. */
-const TARGET_FNS = ['createStaticStyles', 'createStyles'];
-const CALL_RE = new RegExp(`(?:${TARGET_FNS.join('|')})\\s*\\(`, 'g');
+'use strict';
+
+const nodePath = require('path');
+const { injectStylePath } = require('./scripts/stylePathTransform');
 
 /**
  * Resolve the project root directory.
@@ -56,112 +53,16 @@ function resolveRoot(loaderContext) {
   return process.cwd();
 }
 
-module.exports = function injectStylePathLoader(source) {
-  // Fast bail-out
-  if (!CALL_RE.test(source)) return source;
-  CALL_RE.lastIndex = 0;
-
-  const resourcePath = this.resourcePath.replace(/\\/g, '/');
-
-  // Skip the factory implementation files themselves
-  if (
-    (resourcePath.includes('createStaticStyles') || resourcePath.includes('createStyles')) &&
-    resourcePath.endsWith('index.ts')
-  ) {
-    return source;
-  }
-
-  const rootDir = resolveRoot(this);
-
-  // Relative path from project root, forward slashes, no extension
-  const filePath = nodePath
+module.exports = function injectStylePathLoader(source) {
+  const resourcePath = this.resourcePath.replace(/\\/g, '/');
+
+  const rootDir = resolveRoot(this);
+
+  // Relative path from project root, forward slashes, no extension
+  const filePath = nodePath
     .relative(rootDir, this.resourcePath)
-    .replace(/\\/g, '/')
-    .replace(/\.\w+$/, '');
-
-  // Find every target function call
-  const positions = [];
-  let m;
-  while ((m = CALL_RE.exec(source)) !== null) {
-    // Skip if inside a comment
-    const lineStart = source.lastIndexOf('\n', m.index) + 1;
-    const lineText = source.slice(lineStart, m.index).trimStart();
-    if (lineText.startsWith('*') || lineText.startsWith('//')) continue;
-    positions.push(m.index + m[0].length); // right after opening `(`
-  }
-
-  if (positions.length === 0) return source;
-
-  // Process in reverse so indices don't shift
-  let result = source;
-  for (let ci = positions.length - 1; ci >= 0; ci--) {
-    const afterParen = positions[ci];
-
-    // Count parens to find matching close (skip strings and template literals)
-    let depth = 1;
-    let closeIdx = -1;
-    let inStr = false;
-    let strCh = '';
-    let inTpl = false;
-    let tplDepth = 0;
-
-    for (let i = afterParen; i < result.length; i++) {
-      const ch = result[i];
-      const prev = i > 0 ? result[i - 1] : '';
-
-      if (inStr) {
-        if (ch === strCh && prev !== '\\') inStr = false;
-        continue;
-      }
-      if (inTpl) {
-        if (ch === '`' && prev !== '\\') {
-          inTpl = false;
-          continue;
-        }
-        if (ch === '$' && result[i + 1] === '{') {
-          tplDepth++;
-          i++;
-          continue;
-        }
-        if (ch === '}' && tplDepth > 0) {
-          tplDepth--;
-          continue;
-        }
-        continue;
-      }
-      if (ch === '"' || ch === "'") {
-        inStr = true;
-        strCh = ch;
-        continue;
-      }
-      if (ch === '`') {
-        inTpl = true;
-        tplDepth = 0;
-        continue;
-      }
-      if (ch === '(') depth++;
-      if (ch === ')') {
-        depth--;
-        if (depth === 0) {
-          closeIdx = i;
-          break;
-        }
-      }
-    }
-
-    if (closeIdx === -1) continue;
-
-    // Skip if already has a path option
-    const inner = result.slice(afterParen, closeIdx);
-    if (inner.includes('path:')) continue;
-
-    const hasTrailingComma = /,\s*$/.test(inner);
-    const pathArg = hasTrailingComma
-      ? ` { path: '${filePath}' }`
-      : `, { path: '${filePath}' }`;
-
-    result = result.slice(0, closeIdx) + pathArg + result.slice(closeIdx);
-  }
-
-  return result;
-};
+    .replace(/\\/g, '/')
+    .replace(/\.\w+$/, '');
+
+  return injectStylePath(source, filePath, resourcePath);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gomeniucivan/ui",
-  "version": "1.0.54",
+  "version": "1.0.55",
   "private": false,
   "sideEffects": [
     "**/*.css"
@@ -21,7 +21,8 @@
   "files": [
     "dist",
     "loader.js",
-    "next-plugin.js"
+    "next-plugin.js",
+    "scripts/stylePathTransform.js"
   ],
   "scripts": {
     "build": "tsup",

package/scripts/stylePathTransform.js

@@ -0,0 +1,229 @@
+'use strict';
+
+/**
+ * Functions whose calls get a `{ path }` option injected.
+ */
+const TARGET_FNS = ['createStaticStyles', 'createStyles'];
+const CALL_RE = new RegExp(`(?:${TARGET_FNS.join('|')})\\s*\\(`, 'g');
+
+const hasPathProperty = (text) => /\bpath\s*:/.test(text);
+
+const escapePathValue = (value) => value.replace(/\\/g, '/').replace(/'/g, "\\'");
+
+const injectPathIntoObjectLiteral = (objectText, pathValue) => {
+  const trimmed = objectText.trim();
+
+  if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) return null;
+  if (hasPathProperty(trimmed)) return objectText;
+
+  const body = trimmed.slice(1, -1).trim();
+  const injected =
+    body.length === 0
+      ? `{ path: '${escapePathValue(pathValue)}' }`
+      : `{ path: '${escapePathValue(pathValue)}', ${body} }`;
+
+  const leading = objectText.match(/^\s*/)?.[0] ?? '';
+  const trailing = objectText.match(/\s*$/)?.[0] ?? '';
+  return `${leading}${injected}${trailing}`;
+};
+
+/**
+ * Find the matching `)` for a call starting right after `(` and collect
+ * top-level argument commas.
+ */
+const findCallBoundaries = (source, afterParen) => {
+  let depth = 1;
+  let braceDepth = 0;
+  let bracketDepth = 0;
+  let closeIdx = -1;
+  const topLevelCommas = [];
+
+  let inStr = false;
+  let strCh = '';
+  let inTpl = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+
+  for (let i = afterParen; i < source.length; i++) {
+    const ch = source[i];
+    const prev = i > 0 ? source[i - 1] : '';
+    const next = i + 1 < source.length ? source[i + 1] : '';
+
+    if (inLineComment) {
+      if (ch === '\n') inLineComment = false;
+      continue;
+    }
+
+    if (inBlockComment) {
+      if (ch === '*' && next === '/') {
+        inBlockComment = false;
+        i++;
+      }
+      continue;
+    }
+
+    if (inStr) {
+      if (ch === strCh && prev !== '\\') inStr = false;
+      continue;
+    }
+
+    if (inTpl) {
+      if (ch === '`' && prev !== '\\') {
+        inTpl = false;
+      }
+      continue;
+    }
+
+    if (ch === '/' && next === '/') {
+      inLineComment = true;
+      i++;
+      continue;
+    }
+
+    if (ch === '/' && next === '*') {
+      inBlockComment = true;
+      i++;
+      continue;
+    }
+
+    if (ch === '"' || ch === "'") {
+      inStr = true;
+      strCh = ch;
+      continue;
+    }
+
+    if (ch === '`') {
+      inTpl = true;
+      continue;
+    }
+
+    if (ch === '{') {
+      braceDepth++;
+      continue;
+    }
+
+    if (ch === '}') {
+      if (braceDepth > 0) braceDepth--;
+      continue;
+    }
+
+    if (ch === '[') {
+      bracketDepth++;
+      continue;
+    }
+
+    if (ch === ']') {
+      if (bracketDepth > 0) bracketDepth--;
+      continue;
+    }
+
+    if (ch === '(') {
+      depth++;
+      continue;
+    }
+
+    if (ch === ')') {
+      depth--;
+      if (depth === 0) {
+        closeIdx = i;
+        break;
+      }
+      continue;
+    }
+
+    if (ch === ',' && depth === 1 && braceDepth === 0 && bracketDepth === 0) {
+      topLevelCommas.push(i);
+    }
+  }
+
+  if (closeIdx === -1) return null;
+  return { closeIdx, topLevelCommas };
+};
+
+/**
+ * Inject `{ path: '<file-path>' }` into createStyles/createStaticStyles calls.
+ *
+ * Rules:
+ * - One arg call: append second arg `{ path }`
+ * - Two+ arg call:
+ *   - if second arg is object literal and has no `path`, inject into object
+ *   - otherwise append third arg `{ path }` as a fallback
+ */
+const injectStylePath = (source, filePath, resourcePath = '') => {
+  if (!CALL_RE.test(source)) return source;
+  CALL_RE.lastIndex = 0;
+
+  const normalizedResourcePath = resourcePath.replace(/\\/g, '/');
+
+  // Skip the style factory implementation files themselves.
+  if (
+    (normalizedResourcePath.includes('createStaticStyles') ||
+      normalizedResourcePath.includes('createStyles')) &&
+    normalizedResourcePath.endsWith('index.ts')
+  ) {
+    return source;
+  }
+
+  const positions = [];
+  let match;
+  while ((match = CALL_RE.exec(source)) !== null) {
+    const lineStart = source.lastIndexOf('\n', match.index) + 1;
+    const lineText = source.slice(lineStart, match.index).trimStart();
+    if (lineText.startsWith('*') || lineText.startsWith('//')) continue;
+    positions.push(match.index + match[0].length);
+  }
+
+  if (positions.length === 0) return source;
+
+  let result = source;
+  const escapedPath = escapePathValue(filePath);
+
+  for (let pi = positions.length - 1; pi >= 0; pi--) {
+    const afterParen = positions[pi];
+    const callInfo = findCallBoundaries(result, afterParen);
+    if (!callInfo) continue;
+
+    const { closeIdx, topLevelCommas } = callInfo;
+
+    // Single-arg call: add options as second arg.
+    if (topLevelCommas.length === 0) {
+      const inner = result.slice(afterParen, closeIdx);
+      const hasTrailingComma = /,\s*$/.test(inner);
+      result =
+        result.slice(0, closeIdx) +
+        (hasTrailingComma ? ` { path: '${escapedPath}' }` : `, { path: '${escapedPath}' }`) +
+        result.slice(closeIdx);
+      continue;
+    }
+
+    // Two+ args: patch second arg when it's an object literal.
+    const secondStart = topLevelCommas[0] + 1;
+    const secondEnd = topLevelCommas[1] ?? closeIdx;
+    const secondArgRaw = result.slice(secondStart, secondEnd);
+
+    if (hasPathProperty(secondArgRaw)) continue;
+
+    const injectedSecondArg = injectPathIntoObjectLiteral(secondArgRaw, filePath);
+    if (injectedSecondArg !== null) {
+      result =
+        result.slice(0, secondStart) +
+        injectedSecondArg +
+        result.slice(secondEnd);
+      continue;
+    }
+
+    // Fallback for non-object second args.
+    const inner = result.slice(afterParen, closeIdx);
+    const hasTrailingComma = /,\s*$/.test(inner);
+    result =
+      result.slice(0, closeIdx) +
+      (hasTrailingComma ? ` { path: '${escapedPath}' }` : `, { path: '${escapedPath}' }`) +
+      result.slice(closeIdx);
+  }
+
+  return result;
+};
+
+module.exports = {
+  injectStylePath,
+};