@common-stack/rollup-vite-utils 8.0.2-alpha.1 → 8.2.1-alpha.1

package/lib/tools/codegen/templates/common/src/core/event.ts.template

@@ -0,0 +1,326 @@
+/* tslint:disable */
+
+import { Disposable } from './disposable';
+import { MaybePromise } from './types';
+
+/**
+ * Represents a typed event.
+ */
+export interface Event<T> {
+
+    /**
+     *
+     * @param listener The listener function will be call when the event happens.
+     * @param thisArgs The 'this' which will be used when calling the event listener.
+     * @param disposables An array to which a {{IDisposable}} will be added.
+     * @return a disposable to remove the listener again.
+     */
+    (listener: (e: T) => any, thisArgs?: any, disposables?: Disposable[]): Disposable;
+    /**
+     * An emitter will print a warning if more listeners are added for this event.
+     * The event.maxListeners allows the limit to be modified for this specific event.
+     * The value can be set to 0 to indicate an unlimited number of listener.
+     */
+    maxListeners: number
+}
+
+export namespace Event {
+    const _disposable = { dispose(): void { } };
+    export const None: Event<any> = Object.assign(function (): { dispose(): void } { return _disposable; }, {
+        get maxListeners(): number { return 0; },
+        set maxListeners(maxListeners: number) { }
+    });
+
+    /**
+     * Given an event and a `map` function, returns another event which maps each element
+     * through the mapping function.
+     */
+    export function map<I, O>(event: Event<I>, mapFunc: (i: I) => O): Event<O> {
+        return Object.assign((listener: (e: O) => any, thisArgs?: any, disposables?: Disposable[]) => event(i => listener.call(thisArgs, mapFunc(i)), undefined, disposables), {
+            maxListeners: 0,
+        });
+    }
+}
+
+type Callback = (...args: any[]) => any;
+class CallbackList implements Iterable<Callback> {
+
+    private _callbacks: Function[] | undefined;
+    private _contexts: any[] | undefined;
+
+    get length(): number {
+        return this._callbacks && this._callbacks.length || 0;
+    }
+
+    public add(callback: Function, context: any = undefined, bucket?: Disposable[]): void {
+        if (!this._callbacks) {
+            this._callbacks = [];
+            this._contexts = [];
+        }
+        this._callbacks.push(callback);
+        this._contexts!.push(context);
+
+        if (Array.isArray(bucket)) {
+            bucket.push({ dispose: () => this.remove(callback, context) });
+        }
+    }
+
+    public remove(callback: Function, context: any = undefined): void {
+        if (!this._callbacks) {
+            return;
+        }
+
+        let foundCallbackWithDifferentContext = false;
+        for (let i = 0; i < this._callbacks.length; i++) {
+            if (this._callbacks[i] === callback) {
+                if (this._contexts![i] === context) {
+                    // callback & context match => remove it
+                    this._callbacks.splice(i, 1);
+                    this._contexts!.splice(i, 1);
+                    return;
+                } else {
+                    foundCallbackWithDifferentContext = true;
+                }
+            }
+        }
+
+        if (foundCallbackWithDifferentContext) {
+            throw new Error('When adding a listener with a context, you should remove it with the same context');
+        }
+    }
+
+    // tslint:disable-next-line:typedef
+    public [Symbol.iterator]() {
+        if (!this._callbacks) {
+            return [][Symbol.iterator]();
+        }
+        const callbacks = this._callbacks.slice(0);
+        const contexts = this._contexts!.slice(0);
+
+        return callbacks.map((callback, i) =>
+            (...args: any[]) => callback.apply(contexts[i], args)
+        )[Symbol.iterator]();
+    }
+
+    public invoke(...args: any[]): any[] {
+        const ret: any[] = [];
+        for (const callback of this) {
+            try {
+                ret.push(callback(...args));
+            } catch (e) {
+                console.error(e);
+            }
+        }
+        return ret;
+    }
+
+    public isEmpty(): boolean {
+        return !this._callbacks || this._callbacks.length === 0;
+    }
+
+    public dispose(): void {
+        this._callbacks = undefined;
+        this._contexts = undefined;
+    }
+}
+
+export interface EmitterOptions {
+    onFirstListenerAdd?: Function;
+    onLastListenerRemove?: Function;
+}
+
+export class Emitter<T = any> {
+
+    private static LEAK_WARNING_THRESHHOLD = 175;
+
+    private static _noop = function (): void { };
+
+    private _event: Event<T>;
+    private _callbacks: CallbackList | undefined;
+    private _disposed = false;
+
+    private _leakingStacks: Map<string, number> | undefined;
+    private _leakWarnCountdown = 0;
+
+    constructor(
+        private _options?: EmitterOptions
+    ) { }
+
+    /**
+     * For the public to allow to subscribe
+     * to events from this Emitter
+     */
+    get event(): Event<T> {
+        if (!this._event) {
+            this._event = Object.assign((listener: (e: T) => any, thisArgs?: any, disposables?: Disposable[]) => {
+                if (!this._callbacks) {
+                    this._callbacks = new CallbackList();
+                }
+                if (this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty()) {
+                    this._options.onFirstListenerAdd(this);
+                }
+                this._callbacks.add(listener, thisArgs);
+                const removeMaxListenersCheck = this.checkMaxListeners(this._event.maxListeners);
+
+                const result: Disposable = {
+                    dispose: () => {
+                        if (removeMaxListenersCheck) {
+                            removeMaxListenersCheck();
+                        }
+                        result.dispose = Emitter._noop;
+                        if (!this._disposed) {
+                            this._callbacks!.remove(listener, thisArgs);
+                            result.dispose = Emitter._noop;
+                            if (this._options && this._options.onLastListenerRemove && this._callbacks!.isEmpty()) {
+                                this._options.onLastListenerRemove(this);
+                            }
+                        }
+                    }
+                };
+                if (Array.isArray(disposables)) {
+                    disposables.push(result);
+                }
+
+                return result;
+            }, {
+                maxListeners: Emitter.LEAK_WARNING_THRESHHOLD
+            }
+            );
+        }
+        return this._event;
+    }
+
+    protected checkMaxListeners(maxListeners: number): (() => void) | undefined {
+        if (maxListeners === 0 || !this._callbacks) {
+            return undefined;
+        }
+        const listenerCount = this._callbacks.length;
+        if (listenerCount <= maxListeners) {
+            return undefined;
+        }
+
+        const popStack = this.pushLeakingStack();
+
+        this._leakWarnCountdown -= 1;
+        if (this._leakWarnCountdown <= 0) {
+            // only warn on first exceed and then every time the limit
+            // is exceeded by 50% again
+            this._leakWarnCountdown = maxListeners * 0.5;
+
+            let topStack: string;
+            let topCount = 0;
+            this._leakingStacks!.forEach((stackCount, stack) => {
+                if (!topStack || topCount < stackCount) {
+                    topStack = stack;
+                    topCount = stackCount;
+                }
+            });
+
+            // eslint-disable-next-line max-len
+            console.warn(`Possible Emitter memory leak detected. ${listenerCount} listeners added. Use event.maxListeners to increase the limit (${maxListeners}). MOST frequent listener (${topCount}):`);
+            console.warn(topStack!);
+        }
+
+        return popStack;
+    }
+
+    protected pushLeakingStack(): () => void {
+        if (!this._leakingStacks) {
+            this._leakingStacks = new Map();
+        }
+        const stack = new Error().stack!.split('\n').slice(3).join('\n');
+        const count = (this._leakingStacks.get(stack) || 0);
+        this._leakingStacks.set(stack, count + 1);
+        return () => this.popLeakingStack(stack);
+    }
+
+    protected popLeakingStack(stack: string): void {
+        if (!this._leakingStacks) {
+            return;
+        }
+        const count = (this._leakingStacks.get(stack) || 0);
+        this._leakingStacks.set(stack, count - 1);
+    }
+
+    /**
+     * To be kept private to fire an event to
+     * subscribers
+     */
+    fire(event: T): any {
+        if (this._callbacks) {
+            this._callbacks.invoke(event);
+        }
+    }
+
+    /**
+     * Process each listener one by one.
+     * Return `false` to stop iterating over the listeners, `true` to continue.
+     */
+    async sequence(processor: (listener: (e: T) => any) => MaybePromise<boolean>): Promise<void> {
+        if (this._callbacks) {
+            for (const listener of this._callbacks) {
+                if (!await processor(listener)) {
+                    break;
+                }
+            }
+        }
+    }
+
+    dispose(): void {
+        if (this._leakingStacks) {
+            this._leakingStacks.clear();
+            this._leakingStacks = undefined;
+        }
+        if (this._callbacks) {
+            this._callbacks.dispose();
+            this._callbacks = undefined;
+        }
+        this._disposed = true;
+    }
+}
+
+export interface WaitUntilEvent {
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    /**
+     * Allows to pause the event loop until the provided thenable resolved.
+     *
+     * *Note:* It can only be called during event dispatch and not in an asynchronous manner
+     *
+     * @param thenable A thenable that delays execution.
+     */
+    waitUntil(thenable: Promise<any>): void;
+    /* eslint-enable @typescript-eslint/no-explicit-any */
+}
+export namespace WaitUntilEvent {
+    export async function fire<T extends WaitUntilEvent>(
+        emitter: Emitter<T>,
+        event: Pick<T, Exclude<keyof T, 'waitUntil'>>,
+        timeout: number | undefined = undefined
+    ): Promise<void> {
+        const waitables: Promise<void>[] = [];
+        const asyncEvent = Object.assign(event, {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            waitUntil: (thenable: Promise<any>) => {
+                if (Object.isFrozen(waitables)) {
+                    throw new Error('waitUntil cannot be called asynchronously.');
+                }
+                waitables.push(thenable);
+            }
+        }) as T;
+        try {
+            emitter.fire(asyncEvent);
+            // Asynchronous calls to `waitUntil` should fail.
+            Object.freeze(waitables);
+        } finally {
+            delete asyncEvent['waitUntil'];
+        }
+        if (!waitables.length) {
+            return;
+        }
+        if (timeout !== undefined) {
+            await Promise.race([Promise.all(waitables), new Promise(resolve => setTimeout(resolve, timeout))]);
+        } else {
+            await Promise.all(waitables);
+        }
+    }
+}

package/lib/tools/codegen/templates/common/src/core/index.ts.template

@@ -0,0 +1,3 @@
+export * from './disposable';
+export * from './event';
+export * from './types';

package/lib/tools/codegen/templates/common/src/core/types.ts.template

@@ -0,0 +1 @@
+export type MaybePromise<T> = T | PromiseLike<T>;

package/lib/tools/codegen/templates/common/src/generated/service-schemas.ts.template

@@ -0,0 +1 @@
+export const DUMMY2 = 'dummy';

package/lib/tools/codegen/templates/common/src/index.server.ts.template

@@ -1,5 +1,7 @@
 export * from './generated/generated-models';
+export * from './generated/service-schemas';
 export * from './configuration';
 export * from './permissions';
 export * from './apollo-context';
-export * from './types';
+export * from './types';
+export * from './core';

package/lib/tools/codegen/templates/common/src/index.ts.template

@@ -3,3 +3,4 @@ export * from './configuration';
 export * from './permissions';
 export * from './apollo-context';
 export * from './types';
+export * from './core';

package/lib/utils/index.d.ts

@@ -1,4 +1,5 @@
 export * from './utils';
+export * from './packageUtils';
 export * from './withErrorHandleUtil';
 export * from './setupConfig';
 export * from './verifyConfig';

package/lib/utils/packageUtils.cjs

@@ -1,4 +1,4 @@
-'use strict';/**
+'use strict';var fs=require('fs'),path=require('path');function _interopNamespaceDefault(e){var n=Object.create(null);if(e){Object.keys(e).forEach(function(k){if(k!=='default'){var d=Object.getOwnPropertyDescriptor(e,k);Object.defineProperty(n,k,d.get?d:{enumerable:true,get:function(){return e[k]}});}})}n.default=e;return Object.freeze(n)}var fs__namespace=/*#__PURE__*/_interopNamespaceDefault(fs);var path__namespace=/*#__PURE__*/_interopNamespaceDefault(path);/**
  * Extracts the base package name from a full package path
  * Examples:
  * - "@org/package/path/file.js" -> "@org/package"
@@ -15,4 +15,144 @@ const getPackageName = (importPath) => {
         const match = importPath.match(/^([^/]+)/);
         return match ? match[1] : null;
     }
-};exports.getPackageName=getPackageName;//# sourceMappingURL=packageUtils.cjs.map
+};
+/**
+ * Resolves a module to its package.json using Node.js resolution algorithm
+ * with fallbacks for exports restrictions and symlinked packages.
+ *
+ * @param moduleSpec - The module specifier (e.g., 'lodash', '@babel/core', 'package/subpath')
+ * @param esmRequire - The Node.js require function for module resolution
+ * @param options - Optional configuration for resolution behavior
+ * @returns Path to package.json or null if not found
+ */
+function resolvePackageJson(moduleSpec, esmRequire, options = {}) {
+    const { internalPackagePrefix = 'packages-modules/', cwd = process.cwd(), repoRoot } = options;
+    // For internal/local packages, construct path directly
+    if (moduleSpec.startsWith(internalPackagePrefix)) {
+        const localPath = path__namespace.join(cwd, moduleSpec, 'package.json');
+        if (fs__namespace.existsSync(localPath)) {
+            return localPath;
+        }
+        // If not found at cwd and repoRoot is provided, try from repo root
+        if (repoRoot) {
+            const repoRootPath = path__namespace.join(repoRoot, moduleSpec, 'package.json');
+            if (fs__namespace.existsSync(repoRootPath)) {
+                return repoRootPath;
+            }
+        }
+    }
+    // Extract the base package name (handles scoped packages)
+    const packageName = getPackageName(moduleSpec);
+    if (!packageName) {
+        return null;
+    }
+    // Strategy 1: Direct filesystem resolution to bypass exports restrictions
+    const directPath = path__namespace.join(cwd, 'node_modules', packageName, 'package.json');
+    if (fs__namespace.existsSync(directPath)) {
+        return directPath;
+    }
+    // Strategy 2: Standard require.resolve with package.json
+    try {
+        return esmRequire.resolve(path__namespace.join(moduleSpec, 'package.json'));
+    }
+    catch (err) {
+        // Strategy 3: Parse error path to find package root
+        const errorPath = extractPathFromError(err);
+        if (errorPath) {
+            const packageJsonPath = findPackageJsonFromPath(errorPath);
+            if (packageJsonPath && fs__namespace.existsSync(packageJsonPath)) {
+                return packageJsonPath;
+            }
+        }
+        // Strategy 4: Try resolving base package without subpaths
+        const baseModule = removeSubpaths(moduleSpec);
+        if (baseModule !== moduleSpec) {
+            try {
+                return esmRequire.resolve(path__namespace.join(baseModule, 'package.json'));
+            }
+            catch {
+                // Final fallback failed
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Extracts file path from Node.js resolution error.
+ *
+ * @param err - Error object from require.resolve
+ * @returns File path from error or null if not found
+ */
+function extractPathFromError(err) {
+    if (err && typeof err === 'object' && 'path' in err && typeof err.path === 'string') {
+        return err.path;
+    }
+    return null;
+}
+/**
+ * Finds package.json by traversing up from a given path.
+ *
+ * @param filePath - Starting file path
+ * @returns Path to package.json or null if not found
+ */
+function findPackageJsonFromPath(filePath) {
+    // Remove /lib/ segments and everything after them
+    const libSegment = `${path__namespace.sep}lib${path__namespace.sep}`;
+    const libIndex = filePath.indexOf(libSegment);
+    if (libIndex !== -1) {
+        const packageRoot = filePath.slice(0, libIndex);
+        return path__namespace.join(packageRoot, 'package.json');
+    }
+    // Try the directory containing the file
+    const dir = path__namespace.dirname(filePath);
+    const packageJsonPath = path__namespace.join(dir, 'package.json');
+    if (fs__namespace.existsSync(packageJsonPath)) {
+        return packageJsonPath;
+    }
+    return null;
+}
+/**
+ * Removes subpaths from module specifier (e.g., "module/lib/index" -> "module").
+ *
+ * @param moduleSpec - Module specifier with potential subpaths
+ * @returns Base module specifier without subpaths
+ */
+function removeSubpaths(moduleSpec) {
+    if (moduleSpec.includes('/lib')) {
+        return moduleSpec.replace(/\/lib.*$/, '');
+    }
+    return moduleSpec;
+}
+/**
+ * Resolves multiple modules in batch and returns successful resolutions.
+ *
+ * @param moduleSpecs - Array of module specifiers to resolve
+ * @param esmRequire - The Node.js require function for module resolution
+ * @param options - Optional configuration for resolution behavior
+ * @returns Array of objects with moduleSpec and resolved path
+ */
+function resolveMultiplePackages(moduleSpecs, esmRequire, options) {
+    return moduleSpecs.map((moduleSpec) => ({
+        moduleSpec,
+        resolvedPath: resolvePackageJson(moduleSpec, esmRequire, options),
+    }));
+}
+/**
+ * Checks if a module specifier represents an internal/local package.
+ *
+ * @param moduleSpec - Module specifier to check
+ * @param internalPrefix - Prefix for internal packages (defaults to 'packages-modules/')
+ * @returns True if the module is internal/local
+ */
+function isInternalPackage(moduleSpec, internalPrefix = 'packages-modules/') {
+    return moduleSpec.startsWith(internalPrefix);
+}
+/**
+ * Checks if a module specifier represents a scoped package.
+ *
+ * @param moduleSpec - Module specifier to check
+ * @returns True if the module is scoped (starts with @)
+ */
+function isScopedPackage(moduleSpec) {
+    return moduleSpec.startsWith('@');
+}exports.extractPathFromError=extractPathFromError;exports.findPackageJsonFromPath=findPackageJsonFromPath;exports.getPackageName=getPackageName;exports.isInternalPackage=isInternalPackage;exports.isScopedPackage=isScopedPackage;exports.removeSubpaths=removeSubpaths;exports.resolveMultiplePackages=resolveMultiplePackages;exports.resolvePackageJson=resolvePackageJson;//# sourceMappingURL=packageUtils.cjs.map

package/lib/utils/packageUtils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"packageUtils.cjs","sources":["../../src/utils/packageUtils.ts"],"sourcesContent":[null],"names":[],"mappings":"aAAA;;;;;;;AAOG;AACU,MAAA,cAAc,GAAG,CAAC,UAAkB,KAAmB;AAChE,IAAA,IAAI,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;QAC5B,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC;AACnD,QAAA,OAAO,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;KAClC;SAAM;QACH,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;AAC3C,QAAA,OAAO,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;KAClC;AACL"}
+{"version":3,"file":"packageUtils.cjs","sources":["../../src/utils/packageUtils.ts"],"sourcesContent":[null],"names":["path","fs"],"mappings":"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"}

package/lib/utils/packageUtils.d.ts

@@ -7,3 +7,68 @@
  * - "package" -> "package"
  */
 export declare const getPackageName: (importPath: string) => string | null;
+/**
+ * Resolves a module to its package.json using Node.js resolution algorithm
+ * with fallbacks for exports restrictions and symlinked packages.
+ *
+ * @param moduleSpec - The module specifier (e.g., 'lodash', '@babel/core', 'package/subpath')
+ * @param esmRequire - The Node.js require function for module resolution
+ * @param options - Optional configuration for resolution behavior
+ * @returns Path to package.json or null if not found
+ */
+export declare function resolvePackageJson(moduleSpec: string, esmRequire: NodeRequire, options?: {
+    /** Custom base path for internal packages (defaults to 'packages-modules/') */
+    internalPackagePrefix?: string;
+    /** Custom working directory (defaults to process.cwd()) */
+    cwd?: string;
+    /** Custom repo root for internal packages */
+    repoRoot?: string;
+}): string | null;
+/**
+ * Extracts file path from Node.js resolution error.
+ *
+ * @param err - Error object from require.resolve
+ * @returns File path from error or null if not found
+ */
+export declare function extractPathFromError(err: unknown): string | null;
+/**
+ * Finds package.json by traversing up from a given path.
+ *
+ * @param filePath - Starting file path
+ * @returns Path to package.json or null if not found
+ */
+export declare function findPackageJsonFromPath(filePath: string): string | null;
+/**
+ * Removes subpaths from module specifier (e.g., "module/lib/index" -> "module").
+ *
+ * @param moduleSpec - Module specifier with potential subpaths
+ * @returns Base module specifier without subpaths
+ */
+export declare function removeSubpaths(moduleSpec: string): string;
+/**
+ * Resolves multiple modules in batch and returns successful resolutions.
+ *
+ * @param moduleSpecs - Array of module specifiers to resolve
+ * @param esmRequire - The Node.js require function for module resolution
+ * @param options - Optional configuration for resolution behavior
+ * @returns Array of objects with moduleSpec and resolved path
+ */
+export declare function resolveMultiplePackages(moduleSpecs: string[], esmRequire: NodeRequire, options?: Parameters<typeof resolvePackageJson>[2]): Array<{
+    moduleSpec: string;
+    resolvedPath: string | null;
+}>;
+/**
+ * Checks if a module specifier represents an internal/local package.
+ *
+ * @param moduleSpec - Module specifier to check
+ * @param internalPrefix - Prefix for internal packages (defaults to 'packages-modules/')
+ * @returns True if the module is internal/local
+ */
+export declare function isInternalPackage(moduleSpec: string, internalPrefix?: string): boolean;
+/**
+ * Checks if a module specifier represents a scoped package.
+ *
+ * @param moduleSpec - Module specifier to check
+ * @returns True if the module is scoped (starts with @)
+ */
+export declare function isScopedPackage(moduleSpec: string): boolean;