@gjsify/esbuild-plugin-gjsify 0.0.2

package/src/plugin.ts

@@ -0,0 +1,43 @@
+import type { Plugin } from "esbuild";
+import type { PluginOptions } from './types/plugin-options.js';
+import { setupCjsLib, setupEsmLib } from './lib/index.js';
+import { setupForGjs, setupForNode, setupForDeno, setupForBrowser } from './app/index.js';
+
+export const gjsifyPlugin = (pluginOptions: PluginOptions = {}) => {
+    const plugin: Plugin = {
+        name: 'gjsify',
+        async setup(build) {
+
+            // Library mode
+            if(pluginOptions.library) {
+                switch (pluginOptions.library) {
+                    case 'esm':
+                        return setupEsmLib(build, pluginOptions)
+                    case 'cjs':
+                        return setupCjsLib(build, pluginOptions)
+                    default:
+                        throw new TypeError('Unknown library type: ' + pluginOptions.library);
+                }
+            }
+
+            pluginOptions.app ||= 'gjs';
+            
+            // End user applications or tests
+            switch (pluginOptions.app) {
+                case 'gjs':
+                    return await setupForGjs(build, pluginOptions);
+                case 'node':
+                    return await setupForNode(build, pluginOptions);
+                case 'deno':
+                    return await setupForDeno(build, pluginOptions);
+                case 'browser':
+                    return await setupForBrowser(build, pluginOptions);
+                default:
+                    throw new TypeError('Unknown app platform: ' + pluginOptions.app);
+            }
+        }
+    }
+    return plugin;
+};
+
+export default gjsifyPlugin;

package/src/types/app.ts

@@ -0,0 +1 @@
+export type App = 'gjs' | 'node' | 'deno' | 'browser';

package/src/types/index.ts

@@ -0,0 +1,3 @@
+export * from './app.js';
+export * from './plugin-options.js';
+export * from './resolve-alias-options.js';

package/src/types/plugin-options.ts

@@ -0,0 +1,18 @@
+import type { App } from './app.js';
+import type { DeepkitPluginOptions } from '@gjsify/esbuild-plugin-deepkit';
+
+export interface PluginOptions extends DeepkitPluginOptions {
+    debug?: boolean;
+    app?: App;
+    aliases?: Record<string, string>;
+    /** An array of glob patterns to exclude matches and aliases */
+    exclude?: string[];
+    jsExtension?: string;
+    /** Override the format, only be considered if the target app platform is `'node'`, otherwise it is always `'esm'` */
+    format?: 'esm' | 'cjs'
+    /** 
+     * Library Mode
+     * Use this if you want to build a library for Gjsify instead of an end user application.
+     */
+    library?: 'esm' | 'cjs';
+}

package/src/types/resolve-alias-options.ts

@@ -0,0 +1 @@
+export interface ResolveAliasOptions { }

package/src/utils/alias.ts

@@ -0,0 +1,59 @@
+import {
+    EXTERNALS_NODE,
+    EXTERNALS_NPM,
+    ALIASES_GENERAL_FOR_DENO,
+    ALIASES_NODE_FOR_DENO,
+    ALIASES_GJS_FOR_DENO,
+    ALIASES_GENERAL_FOR_GJS,
+    ALIASES_NODE_FOR_GJS,
+    ALIASES_WEB_FOR_GJS,
+    ALIASES_GENERAL_FOR_NODE,
+    ALIASES_GJS_FOR_NODE,
+    ALIASES_WEB_FOR_NODE
+} from "@gjsify/resolve-npm";
+
+import type { ResolveAliasOptions } from '../types/index.js';
+
+export const setNodeAliasPrefix = (ALIASES: Record<string, string>) => {
+    // Also resolve alias names with `npm:${ALIAS}`
+    for (const ALIAS in ALIASES) {
+        if(ALIAS.startsWith('node:')) {
+            continue
+        }
+        const key = `node:${ALIAS}`;
+        if(!ALIASES[key]) ALIASES[key] = ALIASES[ALIAS];
+    }
+    return ALIASES;
+}
+
+const getAliasesGeneralForGjs = (options: ResolveAliasOptions) => ALIASES_GENERAL_FOR_GJS;
+const getAliasesNodeForGjs = (options: ResolveAliasOptions) => setNodeAliasPrefix(ALIASES_NODE_FOR_GJS);
+const getAliasesWebForGjs = (options: ResolveAliasOptions) => ALIASES_WEB_FOR_GJS;
+
+const getAliasesGeneralForDeno = (options: ResolveAliasOptions) => ALIASES_GENERAL_FOR_DENO;
+const getAliasesNodeForDeno = (options: ResolveAliasOptions) => setNodeAliasPrefix(ALIASES_NODE_FOR_DENO);
+const getAliasesGjsForDeno = (options: ResolveAliasOptions) => ALIASES_GJS_FOR_DENO;
+
+const getAliasesGeneralForNode = (options: ResolveAliasOptions) => ALIASES_GENERAL_FOR_NODE;
+const getAliasesGjsForNode = (options: ResolveAliasOptions) => ALIASES_GJS_FOR_NODE;
+const getAliasesWebForNode = (options: ResolveAliasOptions) => ALIASES_WEB_FOR_NODE;
+
+
+export const getAliasesForGjs = (options: ResolveAliasOptions) => {
+    return {...getAliasesGeneralForGjs(options), ...getAliasesNodeForGjs(options), ...getAliasesWebForGjs(options) }
+}
+
+export const getAliasesForDeno = (options: ResolveAliasOptions) => {
+    return {...getAliasesGeneralForDeno(options), ...getAliasesNodeForDeno(options), ...getAliasesGjsForDeno(options) }
+}
+
+export const getAliasesForNode = (options: ResolveAliasOptions) => {
+    return {...getAliasesGeneralForNode(options), ...getAliasesGjsForNode(options), ...getAliasesWebForNode(options) }
+}
+
+/** Array of Node.js build in module names (also with node: prefix) */
+export const externalNode = [...EXTERNALS_NODE, ...EXTERNALS_NODE.map(E => `node:${E}`)];
+
+/** Array of NPM module names for which we have our own implementation */
+export const externalNPM = [...EXTERNALS_NPM];
+

package/src/utils/entry-points.ts

@@ -0,0 +1,33 @@
+import type { BuildOptions } from "esbuild";
+import fastGlob from 'fast-glob';
+
+export const globToEntryPoints = async (_entryPoints: BuildOptions['entryPoints'], ignore: string[] = []) => {
+
+    if(Array.isArray(_entryPoints) && typeof _entryPoints[0] === 'string') {
+        return await fastGlob(_entryPoints as string[], {ignore})
+    } else if(Array.isArray(_entryPoints) && typeof _entryPoints[0] === 'object') {
+        const entryPoints: { in: string, out: string }[] = [];
+
+        for(const entryPoint of _entryPoints as { in: string, out: string }[]) {
+            const inputs = await fastGlob(entryPoint.in, {ignore})
+
+            for (let i = 0; i < inputs.length; i++) {
+                entryPoints.push({
+                    in: inputs[i],
+                    out: entryPoint.out
+                })
+            }
+        }
+
+        return entryPoints;
+    }
+    const entryPoints: Record<string, string> = {};
+    for (const input in _entryPoints as Record<string, string>) {
+        const output = entryPoints[input];
+        const inputs = await fastGlob(input, {ignore});
+        for (const input of inputs) {
+            entryPoints[input] = output;
+        }
+    }
+    return entryPoints;
+}

package/src/utils/extension.ts

@@ -0,0 +1,7 @@
+export const getJsExtensions = (allowExt: string) => {
+    const extensions = {'.js': '.js', '.ts': '.js', '.mts': '.js', '.cts': '.js', '.cjs': '.js', '.mjs': '.js'};
+    if(extensions[allowExt]) {
+        delete extensions[allowExt]
+    }
+    return extensions;
+}

package/src/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './alias.js';
+export * from './entry-points.js';
+export * from './extension.js';

package/tsconfig.json

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