@zaininnari/postcss-cachebuster 0.4.0 → 0.4.1

package/.github/workflows/lint.yml

@@ -0,0 +1,28 @@
+name: Lint
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [20, 22, 24]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Use Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests
+        run: npm run lint

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.4.1 (2026-01-02)
+- Add ESLint
+  - @eslint/js recommended
+  - eslint-plugin-n recommended
+
 ## 0.4.0 (2025-12-30)
 - update dependencies
 - update support node version 20+

package/eslint.config.js

@@ -0,0 +1,22 @@
+import js from "@eslint/js";
+import globals from "globals";
+import n from "eslint-plugin-n";
+import {defineConfig} from "eslint/config";
+
+export default defineConfig([
+    {
+        files: ["**/*.{js,mjs,cjs}"],
+        languageOptions: {
+            ecmaVersion: "latest",
+            sourceType: "module",
+            globals: {
+                ...globals.node,
+                ...globals.mocha,
+                myCustomGlobal: "readonly",
+            },
+        },
+        plugins: {js, n},
+        extends: ["js/recommended", "n/recommended"],
+        ignores: ['eslint.config.js'],
+    },
+]);

package/index.mjs

@@ -1,4 +1,3 @@
-import url from 'url';
 import fs from 'fs';
 import crypto from 'crypto';
 import chalk from 'chalk';
@@ -7,6 +6,15 @@ import path from 'canonical-path';
 
 const checksums = {};
 
+/**
+ * parsed
+ * @typedef {Object} parsed
+ * @property {URL} u
+ * @property {boolean} isAbsolute
+ * @property {boolean} isRootRelativeButNotProtocolRelative
+ * @property {string} originalUrl
+ */
+
 const plugin = (opts = {}) => {
   const pattern = /url\((['"])?([^'")]+)(['"])?\)/g;
   const supportedPropsDefault = [
@@ -56,10 +64,17 @@ const plugin = (opts = {}) => {
     return cachebuster;
   }
 
-  function resolveUrl(assetUrl, file, imagesPath) {
+  /**
+   * @param assetUrl {URL}
+   * @param file {string}
+   * @param imagesPath {string}
+   * @param isRootRelativeButNotProtocolRelative {boolean}
+   * @returns {string}
+   */
+  function resolveUrl(assetUrl, file, imagesPath, isRootRelativeButNotProtocolRelative) {
     let assetPath = decodeURI(assetUrl.pathname);
 
-    if (/^\//.test(assetUrl.pathname)) {
+    if (isRootRelativeButNotProtocolRelative) {
       assetPath = path.join(imagesPath, assetPath);
     } else {
       assetPath = path.join(opts.cssPath || path.dirname(file), assetPath);
@@ -67,14 +82,22 @@ const plugin = (opts = {}) => {
     return assetPath;
   }
 
-  function updateAssetUrl(assetUrl, inputFile) {
-    const assetPath = resolveUrl(assetUrl, inputFile, opts.imagesPath);
+  /**
+   * @param assetUrl {URL}
+   * @param inputFile {string}
+   * @param isRootRelativeButNotProtocolRelative {boolean}
+   */
+  function updateAssetUrl(assetUrl, inputFile, isRootRelativeButNotProtocolRelative) {
+    const assetPath = resolveUrl(assetUrl, inputFile, opts.imagesPath, isRootRelativeButNotProtocolRelative);
 
     // complete url with cachebuster
-    const cachebuster = createCachebuster(assetPath, assetUrl.pathname, opts.type);
+    const originPath = isRootRelativeButNotProtocolRelative ? assetUrl.pathname : assetUrl.pathname.substring(1);
+    const cachebuster = createCachebuster(assetPath, originPath, opts.type);
     if (!cachebuster) {
       return;
-    } else if (typeof opts.type === 'function') {
+    }
+
+    if (typeof opts.type === 'function') {
       assetUrl.pathname = cachebuster;
     } else if (assetUrl.search && assetUrl.search.length > 1) {
       assetUrl.search = assetUrl.search + '&' + opts.paramName + cachebuster;
@@ -83,6 +106,39 @@ const plugin = (opts = {}) => {
     }
   }
 
+  const DUMMY_BASE = 'http://localhost';
+
+  /**
+   * @param input {string}
+   * @returns {parsed}
+   */
+  function parseUrlPreserveRelative(input) {
+    const isAbsolute = /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(input);
+    const isRootRelativeButNotProtocolRelative = /^\/(?!\/)/.test(input);
+    const u = isAbsolute ? new URL(input) : new URL(input, DUMMY_BASE);
+    return {u, isAbsolute, isRootRelativeButNotProtocolRelative, originalUrl: input};
+  }
+
+  /**
+   * @param parsed {parsed}
+   * @returns {string|string}
+   */
+  function formatUrlPreserveRelative(parsed) {
+    const u = parsed.u;
+    const isAbsolute = parsed.isAbsolute;
+    const isRootRelativeButNotProtocolRelative = parsed.isRootRelativeButNotProtocolRelative;
+
+    if (isAbsolute) {
+      return u.toString();
+    }
+    const url = `${u.pathname}${u.search}${u.hash}`;
+    if (!isRootRelativeButNotProtocolRelative) {
+      // remove start slash
+      return  url.substring(1);
+    }
+    return url;
+  }
+
   return {
     postcssPlugin: 'postcss-cachebuster',
     Once(root) {
@@ -96,10 +152,10 @@ const plugin = (opts = {}) => {
         const quote = results[1] || '"';
         const originalUrl = results[2];
 
-        const assetUrl = url.parse(originalUrl);
-        updateAssetUrl(assetUrl, inputFile);
+        const parsed = parseUrlPreserveRelative(originalUrl);
+        updateAssetUrl(parsed.u, inputFile, parsed.isRootRelativeButNotProtocolRelative, parsed.originalUrl);
 
-        atrule.params = 'url(' + quote + url.format(assetUrl) + quote + ')';
+        atrule.params = 'url(' + quote + formatUrlPreserveRelative(parsed) + quote + ')';
       });
 
       root.walkDecls(function walkThroughtDeclarations(declaration) {
@@ -111,20 +167,22 @@ const plugin = (opts = {}) => {
         declaration.value = declaration.value.replace(pattern, function (match, quote, originalUrl) {
           quote = quote || '"';
 
-          const assetUrl = url.parse(originalUrl);
+          const parsed = parseUrlPreserveRelative(originalUrl);
+          const assetUrl = parsed.u;
 
           // only locals
           if (
-            assetUrl.host ||
+            assetUrl.toString().indexOf(DUMMY_BASE) !== 0 ||
+            parsed.isAbsolute ||
             assetUrl.pathname.indexOf('//') === 0 ||
             assetUrl.pathname.indexOf(';base64') !== -1
           ) {
             return match;
           }
 
-          updateAssetUrl(assetUrl, inputFile);
+          updateAssetUrl(assetUrl, inputFile, parsed.isRootRelativeButNotProtocolRelative);
 
-          return 'url(' + quote + url.format(assetUrl) + quote + ')';
+          return 'url(' + quote + formatUrlPreserveRelative(parsed) + quote + ')';
         });
       });
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zaininnari/postcss-cachebuster",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Fork of postcss-cachebuster. Cachebusting all local files in css",
   "keywords": [
     "postcss",
@@ -38,7 +38,11 @@
     "path": "^0.12.7"
   },
   "devDependencies": {
+    "@eslint/js": "^9.39.2",
     "chai": "^6.2.2",
+    "eslint": "^9.39.2",
+    "eslint-plugin-n": "^17.23.1",
+    "globals": "^16.5.0",
     "gulp": "^5.0.1",
     "gulp-mocha": "^10.0.1",
     "gulp-postcss": "^10.0.0",
@@ -50,6 +54,7 @@
     "glob": "9.3.5"
   },
   "scripts": {
+    "lint": "eslint .",
     "test": "gulp --gulpfile gulpfile.mjs"
   }
 }

package/.eslintrc.json

@@ -1,13 +0,0 @@
-
-{
-  "rules": {
-    "max-len": 0,
-    "indent": ["error", 2, { "VariableDeclarator": 1 }],
-    "global-require": 0,
-    "func-names": 0,
-    "prefer-rest-params": 1,
-    "strict": 1,
-    "no-param-reassign": 0
-  }
-}
-