@gjsify/esbuild-plugin-alias 0.0.3

package/README.md

@@ -0,0 +1 @@
+# @gjsify/esbuild-plugin-alias

package/dist/cjs/index.cjs

@@ -0,0 +1,80 @@
+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
+});

package/dist/esm/index.mjs

@@ -0,0 +1,54 @@
+// src/plugin.ts
+import { existsSync } from "fs";
+import { realpath } from "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 (existsSync(resolvedAliasPath)) {
+            resolvedAliasPath = await realpath(resolvedAliasPath);
+          }
+          return {
+            path: resolvedAliasPath,
+            namespace
+          };
+        }
+        return null;
+      });
+    }
+  };
+  return plugin;
+};
+export {
+  aliasPlugin
+};

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from './plugin.js';

package/dist/types/plugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "esbuild";
+export declare const aliasPlugin: (aliasObj: Record<string, string>) => Plugin;
+export default aliasPlugin;

package/esbuild.mjs

@@ -0,0 +1,49 @@
+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 = {
+    entryPoints: ['src/index.ts'],
+    bundle: true,
+    minify: false,
+    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

@@ -0,0 +1,32 @@
+{
+  "name": "@gjsify/esbuild-plugin-alias",
+  "version": "0.0.3",
+  "description": "",
+  "type": "module",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.mjs",
+  "types": "dist/types/index.d.ts",
+  "scripts": {
+    "clear": "rm -rf dist tsconfig.tsbuildinfo",
+    "print:name": "echo '@gjsify/esbuild-plugin-alias'",
+    "build": "yarn print:name && yarn build:js && yarn build:types",
+    "build:js": "node esbuild.mjs",
+    "build:types": "tsc --emitDeclarationOnly"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gjsify/gjsify.git"
+  },
+  "bugs": {
+    "url": "https://github.com/gjsify/gjsify/issues"
+  },
+  "homepage": "https://github.com/gjsify/gjsify/tree/main/packages/infra/esbuild-plugin-alias#readme",
+  "keywords": [
+    "esbuild",
+    "plugin"
+  ],
+  "devDependencies": {
+    "esbuild": "^0.18.3",
+    "typescript": "^5.1.3"
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './plugin.js';

package/src/plugin.ts

@@ -0,0 +1,71 @@
+import { existsSync } from "fs";
+import { realpath } from "fs/promises";
+
+import type { Plugin } from "esbuild";
+
+function escapeRegExp(str: string) {
+  // $& means the whole matched string
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+
+export const aliasPlugin = (aliasObj: Record<string, string>) => {
+  const aliases = Object.keys(aliasObj);
+  const re = new RegExp(`^(${aliases.map(x => escapeRegExp(x)).join('|')})$`);
+
+  const plugin: Plugin = {
+    name: 'alias',
+    setup(build) {
+      // we do not register 'file' namespace here, because the root file won't be processed
+      // https://github.com/evanw/esbuild/issues/791
+      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: 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);
+          }
+
+          // console.debug(`resolvedAliasPath: ${args.path} -> ${resolvedAliasPath}`);
+
+          return {
+            path: resolvedAliasPath,
+            namespace: namespace,
+          }
+        }
+
+        return null;
+      });
+    },
+  };
+
+  return plugin;
+};
+
+export default aliasPlugin;

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "module": "ESNext",
+    "target": "ESNext",
+    "outDir": "dist",
+    "types": ["node"],
+    "declarationDir": "dist/types",
+    "declaration": true,
+    "allowSyntheticDefaultImports": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true
+  },
+  "files": ["src/index.ts"]
+}