@eik/postcss-plugin 4.0.0 → 4.0.2

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [4.0.2](https://github.com/eik-lib/postcss-import-map/compare/v4.0.1...v4.0.2) (2024-08-12)
+
+
+### Bug Fixes
+
+* **deps:** update dependency @eik/common to v4.0.8 ([169bffa](https://github.com/eik-lib/postcss-import-map/commit/169bffa9abe95c6d79e5987c679f4e1e619e94ee))
+
+## [4.0.1](https://github.com/eik-lib/postcss-import-map/compare/v4.0.0...v4.0.1) (2024-08-09)
+
+
+### Bug Fixes
+
+* include type definitions ([7ad7a16](https://github.com/eik-lib/postcss-import-map/commit/7ad7a16ea7f4ca246383cf1b8797f45b0dd2995d))
+
 # [4.0.0](https://github.com/eik-lib/postcss-import-map/compare/v3.0.14...v4.0.0) (2024-07-29)
 
 

package/package.json

@@ -1,19 +1,25 @@
 {
   "name": "@eik/postcss-plugin",
-  "version": "4.0.0",
+  "version": "4.0.2",
   "description": "PostCSS plugin that uses Eik defined import map files to transform bare import specifiers to absolute URLs in @import rules",
   "main": "src/plugin.js",
+  "types": "./types/plugin.d.ts",
   "type": "module",
   "files": [
     "CHANGELOG.md",
     "package.json",
-    "src/"
+    "src/",
+    "types/"
   ],
   "scripts": {
+    "clean": "rimraf .tap node_modules types",
     "test": "tap test/*.js --disable-coverage --allow-empty-coverage",
     "test:snapshot": "TAP_SNAPSHOT=1 tap test/*.js --disable-coverage --allow-empty-coverage",
     "lint": "eslint .",
-    "lint:fix": "eslint . --fix"
+    "lint:fix": "eslint . --fix",
+    "types": "run-s types:module types:test",
+    "types:module": "tsc",
+    "types:test": "tsc --project tsconfig.test.json"
   },
   "repository": {
     "type": "git",
@@ -33,25 +39,23 @@
   },
   "homepage": "https://github.com/eik-lib/postcss-import-map#readme",
   "devDependencies": {
-    "@semantic-release/changelog": "6.0.3",
-    "@semantic-release/commit-analyzer": "13.0.0",
-    "@semantic-release/git": "10.0.1",
-    "@semantic-release/github": "10.1.3",
-    "@semantic-release/npm": "12.0.1",
-    "@semantic-release/release-notes-generator": "14.0.1",
-    "eslint": "9.8.0",
-    "eslint-config-prettier": "9.1.0",
-    "eslint-plugin-prettier": "5.2.1",
+    "@eik/eslint-config": "1.0.2",
+    "@eik/prettier-config": "1.0.1",
+    "@eik/semantic-release-config": "1.0.0",
+    "@eik/typescript-config": "1.0.0",
+    "eslint": "9.9.0",
     "fastify": "4.28.1",
-    "globals": "15.8.0",
-    "postcss": "8.4.40",
-    "rollup": "4.19.1",
-    "semantic-release": "24.0.0",
+    "npm-run-all2": "5.0.0",
+    "postcss": "8.4.41",
     "prettier": "3.3.3",
-    "tap": "20.0.3"
+    "rimraf": "6.0.1",
+    "rollup": "4.20.0",
+    "semantic-release": "24.0.0",
+    "tap": "20.0.3",
+    "typescript": "5.5.4"
   },
   "dependencies": {
-    "@eik/common-config-loader": "4.0.0-next.12",
+    "@eik/common": "4.0.8",
     "css-url-parser": "1.1.3"
   },
   "peerDependencies": {

package/src/plugin.js

@@ -1,118 +1,163 @@
-import parseCssUrls from 'css-url-parser';
-import { getDefaults } from '@eik/common-config-loader';
-
-const notUrl = (url) => url.substr(0, 4) !== 'http';
-
+import parseCssUrls from "css-url-parser";
+import { helpers } from "@eik/common";
+
+/**
+ * @param {string} url
+ * @returns {boolean}
+ */
+const notUrl = (url) => url.substr(0, 4) !== "http";
+
+/**
+ * @typedef {object} ImportMap
+ * @property {Record<string, string>} imports
+ */
+
+/**
+ * @param {string[]} urls
+ * @returns {Promise<ImportMap[]>}
+ */
 async function fetchImportMaps(urls = []) {
-    try {
-        const maps = urls.map((map) =>
-            fetch(map).then((result) => {
-                if (result.status === 404) {
-                    throw new Error('Import map could not be found on server');
-                } else if (result.status >= 400 && result.status < 500) {
-                    throw new Error('Server rejected client request');
-                } else if (result.status >= 500) {
-                    throw new Error('Server error');
-                }
-                return result.json();
-            }),
-        );
-        return await Promise.all(maps);
-    } catch (err) {
-        throw new Error(
-            `Unable to load import map file from server: ${err.message}`,
-        );
-    }
+	try {
+		const maps = urls.map((map) =>
+			fetch(map).then((result) => {
+				if (result.status === 404) {
+					throw new Error("Import map could not be found on server");
+				} else if (result.status >= 400 && result.status < 500) {
+					throw new Error("Server rejected client request");
+				} else if (result.status >= 500) {
+					throw new Error("Server error");
+				}
+				return /** @type {Promise<ImportMap>} */ (result.json());
+			}),
+		);
+		return await Promise.all(maps);
+	} catch (err) {
+		throw new Error(
+			`Unable to load import map file from server: ${err.message}`,
+		);
+	}
 }
 
+/**
+ * @param {ImportMap} map
+ * @returns {Array<{ key: string; value: string; }>}
+ */
 const validate = (map) =>
-    Object.keys(map.imports).map((key) => {
-        const value = map.imports[key];
-
-        if (notUrl(value)) {
-            throw Error(
-                `Import specifier can NOT be mapped to a bare import statement. Import specifier "${key}" is being wrongly mapped to "${value}"`,
-            );
-        }
-
-        return { key, value };
-    });
-
+	Object.keys(map.imports).map((key) => {
+		const value = map.imports[key];
+
+		if (notUrl(value)) {
+			throw Error(
+				`Import specifier can NOT be mapped to a bare import statement. Import specifier "${key}" is being wrongly mapped to "${value}"`,
+			);
+		}
+
+		return { key, value };
+	});
+
+/**
+ * @typedef {object} PluginOptions
+ * @property {string} [path=process.cwd()]
+ * @property {string[]} [urls=[]] URLs to import maps hosted on an Eik server. Takes precedence over `eik.json`.
+ * @property {ImportMap[]} [maps=[]] Inline import maps that should be used. Takes precedence over `urls` and `eik.json`.
+ */
+
+/**
+ * @typedef {object} PrepareResult
+ * @property {(root: import('postcss').Root) => Promise<void>} Once
+ * @property {{ import: (decl: import('postcss').AtRule) => Promise<void> }} AtRule
+ */
+
+/**
+ * @typedef {object} Plugin
+ * @property {string} postcssPlugin
+ * @property {() => PrepareResult} prepare
+ */
+
+/**
+ * Returns the plugin which will apply the given import maps during the build.
+ * @param {PluginOptions} options
+ * @returns {Plugin}
+ */
 export default ({ path = process.cwd(), maps = [], urls = [] } = {}) => {
-    const pMaps = Array.isArray(maps) ? maps : [maps];
-    const pUrls = Array.isArray(urls) ? urls : [urls];
-
-    return {
-        postcssPlugin: '@eik/postcss-import-map',
-        prepare() {
-            // Avoid parsing things more than necessary
-            const processed = new WeakMap();
-            // Only replace once per url
-            const replaced = new Set();
-            // Eagerly start resolving
-
-            // Reused replace logic
-            const applyImportMap = (mapping, decl) => {
-                if (processed.has(decl)) {
-                    return;
-                }
-
-                let key;
-                // First check if it's possibly using syntax like url()
-                const parsedUrls = parseCssUrls(decl.params);
-                if (parsedUrls.length > 0) {
-                    key = parsedUrls[0];
-                } else {
-                    // Handle the common cases where it's not wrapped in url() but may have quotes
-                    key = decl.params.replace(/["']/g, '');
-                }
-
-                // Webpack interop
-                key = key.replace(/^~/, '');
-
-                if (replaced.has(key)) {
-                    decl.remove();
-                } else if (mapping.has(key)) {
-                    decl.params = `'${mapping.get(key)}'`;
-                    replaced.add(key);
-                }
-
-                // Cache we've processed this
-                processed.set(decl, true);
-            };
-
-            const mapping = new Map();
-
-            return {
-                // Run initially once, this is to ensure it runs before postcss-import
-                async Once(root) {
-                    // Load eik config from eik.json or package.json
-                    const config = await getDefaults(path);
-
-                    // Fetch import maps from the server
-                    const fetched = await fetchImportMaps([
-                        ...config.map,
-                        ...pUrls,
-                    ]);
-
-                    const allImportMaps = [...fetched, ...pMaps];
-                    allImportMaps.forEach((item) => {
-                        const i = validate(item);
-                        i.forEach((obj) => {
-                            mapping.set(obj.key, obj.value);
-                        });
-                    });
-
-                    root.walkAtRules('import', (decl) => {
-                        applyImportMap(mapping, decl);
-                    });
-                },
-                AtRule: {
-                    import: async (decl) => {
-                        applyImportMap(mapping, decl);
-                    },
-                },
-            };
-        },
-    };
+	const pMaps = Array.isArray(maps) ? maps : [maps];
+	const pUrls = Array.isArray(urls) ? urls : [urls];
+
+	return {
+		postcssPlugin: "@eik/postcss-import-map",
+		prepare() {
+			// Avoid parsing things more than necessary
+			const processed = new WeakMap();
+			// Only replace once per url
+			const replaced = new Set();
+			// Eagerly start resolving
+
+			// Reused replace logic
+			/**
+			 *
+			 * @param {Map<string, string>} mapping
+			 * @param {import('postcss').AtRule} decl
+			 * @returns {void}
+			 */
+			const applyImportMap = (mapping, decl) => {
+				if (processed.has(decl)) {
+					return;
+				}
+
+				let key;
+				// First check if it's possibly using syntax like url()
+				const parsedUrls = parseCssUrls(decl.params);
+				if (parsedUrls.length > 0) {
+					key = parsedUrls[0];
+				} else {
+					// Handle the common cases where it's not wrapped in url() but may have quotes
+					key = decl.params.replace(/["']/g, "");
+				}
+
+				// Webpack interop
+				key = key.replace(/^~/, "");
+
+				if (replaced.has(key)) {
+					decl.remove();
+				} else if (mapping.has(key)) {
+					decl.params = `'${mapping.get(key)}'`;
+					replaced.add(key);
+				}
+
+				// Cache we've processed this
+				processed.set(decl, true);
+			};
+
+			/** @type {Map<string, string>} */
+			const mapping = new Map();
+
+			return {
+				// Run initially once, this is to ensure it runs before postcss-import
+				async Once(root) {
+					// Load eik config from eik.json or package.json
+					const config = await helpers.getDefaults(path);
+
+					// Fetch import maps from the server
+					const fetched = await fetchImportMaps([...config.map, ...pUrls]);
+
+					const allImportMaps = [...fetched, ...pMaps];
+					allImportMaps.forEach((item) => {
+						const i = validate(item);
+						i.forEach((obj) => {
+							mapping.set(obj.key, obj.value);
+						});
+					});
+
+					root.walkAtRules("import", (decl) => {
+						applyImportMap(mapping, decl);
+					});
+				},
+				AtRule: {
+					import: async (decl) => {
+						applyImportMap(mapping, decl);
+					},
+				},
+			};
+		},
+	};
 };

package/types/plugin.d.ts

@@ -0,0 +1,26 @@
+declare function _default({ path, maps, urls }?: PluginOptions): Plugin;
+export default _default;
+export type ImportMap = {
+    imports: Record<string, string>;
+};
+export type PluginOptions = {
+    path?: string;
+    /**
+     * URLs to import maps hosted on an Eik server. Takes precedence over `eik.json`.
+     */
+    urls?: string[];
+    /**
+     * Inline import maps that should be used. Takes precedence over `urls` and `eik.json`.
+     */
+    maps?: ImportMap[];
+};
+export type PrepareResult = {
+    Once: (root: import("postcss").Root) => Promise<void>;
+    AtRule: {
+        import: (decl: import("postcss").AtRule) => Promise<void>;
+    };
+};
+export type Plugin = {
+    postcssPlugin: string;
+    prepare: () => PrepareResult;
+};