@gjsify/esbuild-plugin-alias 0.0.3 → 0.1.0

package/README.md

@@ -1 +1,33 @@
 # @gjsify/esbuild-plugin-alias
+
+esbuild plugin for module aliasing. Used internally by @gjsify/esbuild-plugin-gjsify.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+npm install @gjsify/esbuild-plugin-alias
+# or
+yarn add @gjsify/esbuild-plugin-alias
+```
+
+## Usage
+
+```typescript
+import { build } from 'esbuild';
+import { aliasPlugin } from '@gjsify/esbuild-plugin-alias';
+
+await build({
+  entryPoints: ['src/index.ts'],
+  bundle: true,
+  outfile: 'dist/index.js',
+  plugins: [aliasPlugin({
+    'original-module': 'replacement-module',
+  })],
+});
+```
+
+## License
+
+MIT

package/dist/esm/index.mjs

@@ -13,37 +13,40 @@ var aliasPlugin = (aliasObj) => {
       build.onResolve({ filter: re }, async (args) => {
         let resolvedAliasPath = aliasObj[args.path];
         let namespace = args.namespace;
-        if (resolvedAliasPath) {
-          if (resolvedAliasPath.startsWith("http://")) {
-            namespace = "http";
-            resolvedAliasPath = resolvedAliasPath.slice(5);
-          } else if (resolvedAliasPath.startsWith("https://")) {
-            namespace = "https";
-            resolvedAliasPath = resolvedAliasPath.slice(6);
+        if (!resolvedAliasPath) {
+          return null;
+        }
+        if (resolvedAliasPath.startsWith("http://")) {
+          namespace = "http";
+          resolvedAliasPath = resolvedAliasPath.slice(5);
+        } else if (resolvedAliasPath.startsWith("https://")) {
+          namespace = "https";
+          resolvedAliasPath = resolvedAliasPath.slice(6);
+        } else {
+          const resolvedAlias = await build.resolve(resolvedAliasPath, {
+            importer: args.importer,
+            kind: args.kind,
+            namespace,
+            resolveDir: args.resolveDir,
+            pluginData: args.pluginData
+          });
+          if (resolvedAlias.errors.length > 0) {
+            console.error(resolvedAlias.errors);
+            return resolvedAlias;
+          } else if (resolvedAlias.external) {
+            return { path: resolvedAlias.path, external: true };
           } else {
-            const resolvedAlias = await build.resolve(resolvedAliasPath, {
-              importer: args.importer,
-              kind: args.kind,
-              namespace,
-              resolveDir: args.resolveDir,
-              pluginData: args.pluginData
-            });
-            if (resolvedAlias.errors) {
-              return resolvedAlias;
-            } else {
-              resolvedAliasPath = resolvedAlias.path;
-              namespace = resolvedAlias.namespace;
-            }
-          }
-          if (existsSync(resolvedAliasPath)) {
-            resolvedAliasPath = await realpath(resolvedAliasPath);
+            resolvedAliasPath = resolvedAlias.path;
+            namespace = resolvedAlias.namespace;
           }
-          return {
-            path: resolvedAliasPath,
-            namespace
-          };
         }
-        return null;
+        if (existsSync(resolvedAliasPath)) {
+          resolvedAliasPath = await realpath(resolvedAliasPath);
+        }
+        return {
+          path: resolvedAliasPath,
+          namespace
+        };
       });
     }
   };

package/esbuild.mjs

@@ -1,49 +1,18 @@
 import { build } from 'esbuild';
-import { readFile } from 'fs/promises';
-import { extname, dirname } from 'path';
 import { EXTERNALS_NODE } from '@gjsify/resolve-npm';
 
-const pkg = JSON.parse(
-    await readFile(
-      new URL('./package.json', import.meta.url), 'utf8'
-    )
-);
-
-if (!pkg.main && !pkg.module) {
-    throw new Error("package.json: The main or module property is required!");
-}
-
-const baseConfig = {
+await build({
     entryPoints: ['src/index.ts'],
     bundle: true,
     minify: false,
+    format: 'esm',
+    outfile: 'dist/esm/index.mjs',
     external: [
         ...EXTERNALS_NODE,
         'typescript',
         '@deepkit/type-compiler',
         'esbuild',
-        // '@gjsify/resolve-npm', can't be required in cjs builds
-        '@gjsify/esbuild-plugin-deno-loader',
         '@gjsify/esbuild-plugin-deepkit',
         '@gjsify/esbuild-plugin-gjsify',
-    ]
-}
-
-if (pkg.main) {
-    build({
-        ...baseConfig,
-        outdir: dirname(pkg.main),
-        format: 'cjs',
-        outExtension: {'.js': extname(pkg.main)},
-        platform: "node",
-    });    
-}
-
-if (pkg.module) {
-    build({
-        ...baseConfig,
-        outdir: dirname(pkg.module),
-        format: 'esm',
-        outExtension: {'.js': extname(pkg.module)},
-    });
-}
+    ],
+});

package/package.json

@@ -1,15 +1,20 @@
 {
   "name": "@gjsify/esbuild-plugin-alias",
-  "version": "0.0.3",
+  "version": "0.1.0",
   "description": "",
   "type": "module",
-  "main": "dist/cjs/index.cjs",
-  "module": "dist/esm/index.mjs",
+  "main": "dist/esm/index.mjs",
   "types": "dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./dist/esm/index.mjs"
+    }
+  },
   "scripts": {
-    "clear": "rm -rf dist tsconfig.tsbuildinfo",
-    "print:name": "echo '@gjsify/esbuild-plugin-alias'",
-    "build": "yarn print:name && yarn build:js && yarn build:types",
+    "clear": "rm -rf dist tsconfig.tsbuildinfo || exit 0",
+    "check": "tsc --noEmit",
+    "build": "yarn build:js && yarn build:types",
     "build:js": "node esbuild.mjs",
     "build:types": "tsc --emitDeclarationOnly"
   },
@@ -26,7 +31,7 @@
     "plugin"
   ],
   "devDependencies": {
-    "esbuild": "^0.18.3",
-    "typescript": "^5.1.3"
+    "esbuild": "^0.27.4",
+    "typescript": "^6.0.2"
   }
 }

package/src/plugin.ts

@@ -23,44 +23,44 @@ export const aliasPlugin = (aliasObj: Record<string, string>) => {
 
         let namespace = args.namespace;
 
-        if (resolvedAliasPath) {
-
-          if (resolvedAliasPath.startsWith('http://')) {
-            namespace = 'http';
-            resolvedAliasPath = resolvedAliasPath.slice(5)
-          } else if (resolvedAliasPath.startsWith('https://')) {
-            namespace = 'https';
-            resolvedAliasPath = resolvedAliasPath.slice(6)
-          } else {
-            const resolvedAlias = (await build.resolve(resolvedAliasPath, {
-              importer: args.importer,
-              kind: args.kind,
-              namespace: namespace,
-              resolveDir: args.resolveDir,
-              pluginData: args.pluginData,
-            }));
+        if (!resolvedAliasPath) {
+          return null;
+        }
 
-            if (resolvedAlias.errors) {
-              return resolvedAlias;
-            } else {
-              resolvedAliasPath = resolvedAlias.path;
-              namespace = resolvedAlias.namespace;
-            }
-          }
+        if (resolvedAliasPath.startsWith('http://')) {
+          namespace = 'http';
+          resolvedAliasPath = resolvedAliasPath.slice(5)
+        } else if (resolvedAliasPath.startsWith('https://')) {
+          namespace = 'https';
+          resolvedAliasPath = resolvedAliasPath.slice(6)
+        } else {
+          const resolvedAlias = (await build.resolve(resolvedAliasPath, {
+            importer: args.importer,
+            kind: args.kind,
+            namespace: namespace,
+            resolveDir: args.resolveDir,
+            pluginData: args.pluginData,
+          }));
 
-          if (existsSync(resolvedAliasPath)) {
-            resolvedAliasPath = await realpath(resolvedAliasPath);
+          if (resolvedAlias.errors.length > 0) {
+            console.error(resolvedAlias.errors);
+            return resolvedAlias;
+          } else if (resolvedAlias.external) {
+            return { path: resolvedAlias.path, external: true };
+          } else {
+            resolvedAliasPath = resolvedAlias.path;
+            namespace = resolvedAlias.namespace;
           }
+        }
 
-          // console.debug(`resolvedAliasPath: ${args.path} -> ${resolvedAliasPath}`);
-
-          return {
-            path: resolvedAliasPath,
-            namespace: namespace,
-          }
+        if (existsSync(resolvedAliasPath)) {
+          resolvedAliasPath = await realpath(resolvedAliasPath);
         }
 
-        return null;
+        return {
+          path: resolvedAliasPath,
+          namespace: namespace,
+        };
       });
     },
   };

package/tsconfig.json

@@ -2,13 +2,19 @@
   "compilerOptions": {
     "module": "ESNext",
     "target": "ESNext",
+    "rootDir": "src",
     "outDir": "dist",
-    "types": ["node"],
+    "types": [
+      "node"
+    ],
     "declarationDir": "dist/types",
     "declaration": true,
-    "allowSyntheticDefaultImports": true,
     "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true
+    "allowImportingTsExtensions": true,
+    "emitDeclarationOnly": true,
+    "strict": false
   },
-  "files": ["src/index.ts"]
-}
+  "files": [
+    "src/index.ts"
+  ]
+}

package/dist/cjs/index.cjs

@@ -1,80 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  aliasPlugin: () => aliasPlugin
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/plugin.ts
-var import_fs = require("fs");
-var import_promises = require("fs/promises");
-function escapeRegExp(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-var aliasPlugin = (aliasObj) => {
-  const aliases = Object.keys(aliasObj);
-  const re = new RegExp(`^(${aliases.map((x) => escapeRegExp(x)).join("|")})$`);
-  const plugin = {
-    name: "alias",
-    setup(build) {
-      build.onResolve({ filter: re }, async (args) => {
-        let resolvedAliasPath = aliasObj[args.path];
-        let namespace = args.namespace;
-        if (resolvedAliasPath) {
-          if (resolvedAliasPath.startsWith("http://")) {
-            namespace = "http";
-            resolvedAliasPath = resolvedAliasPath.slice(5);
-          } else if (resolvedAliasPath.startsWith("https://")) {
-            namespace = "https";
-            resolvedAliasPath = resolvedAliasPath.slice(6);
-          } else {
-            const resolvedAlias = await build.resolve(resolvedAliasPath, {
-              importer: args.importer,
-              kind: args.kind,
-              namespace,
-              resolveDir: args.resolveDir,
-              pluginData: args.pluginData
-            });
-            if (resolvedAlias.errors) {
-              return resolvedAlias;
-            } else {
-              resolvedAliasPath = resolvedAlias.path;
-              namespace = resolvedAlias.namespace;
-            }
-          }
-          if ((0, import_fs.existsSync)(resolvedAliasPath)) {
-            resolvedAliasPath = await (0, import_promises.realpath)(resolvedAliasPath);
-          }
-          return {
-            path: resolvedAliasPath,
-            namespace
-          };
-        }
-        return null;
-      });
-    }
-  };
-  return plugin;
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  aliasPlugin
-});