@nodesecure/scanner/dist/extractors/payload.js

A package API to run a static analysis of your module's dependencies.

// @ts-ignore
import deepmerge from "@fastify/deepmerge";
import { isNodesecurePayload } from "../utils/isNodesecurePayload.js";
// CONSTANTS
const kFastMerge = deepmerge({ all: true });
export class Payload extends EventTarget {
    dependencies;
    probes;
    cachedResult;
    constructor(data, probes) {
        super();
        this.dependencies = isNodesecurePayload(data) ?
            data.dependencies :
            data;
        this.probes = probes.reduce((data, probe) => {
            data[probe.level].push(probe);
            return data;
        }, { packument: [], manifest: [] });
    }
    extract() {
        if (this.cachedResult) {
            return this.cachedResult;
        }
        for (const [name, dependency] of Object.entries(this.dependencies)) {
            this.probes.packument.forEach((probe) => probe.next(name, dependency));
            this.#emit("packument", name, dependency);
            if (this.probes.manifest.length > 0) {
                for (const [spec, depVersion] of Object.entries(dependency.versions)) {
                    this.probes.manifest.forEach((probe) => probe.next(spec, depVersion, { name, dependency }));
                    this.#emit("manifest", spec, depVersion, { name, dependency });
                }
            }
        }
        this.cachedResult = [
            ...this.probes.packument.map((probe) => probe.done()),
            ...this.probes.manifest.map((probe) => probe.done())
        ];
        return this.cachedResult;
    }
    extractAndMerge() {
        return kFastMerge(...this.extract());
    }
    on(e, listener) {
        if (e === "error") {
            function wrappedErrorListener(event) {
                const customErrorEvent = event;
                try {
                    listener(customErrorEvent.detail);
                }
                catch (error) {
                    console.warn("Something went wrong in error listener", { cause: error });
                }
            }
            this.addEventListener(e, wrappedErrorListener);
            return this;
        }
        const wrappedListener = (event) => {
            const customEvent = event;
            try {
                listener(...customEvent.detail);
            }
            catch (error) {
                this.#emitError(new Error(`An error occured during ${e} event`, { cause: error }));
            }
        };
        this.addEventListener(e, wrappedListener);
        return this;
    }
    #emit(event, ...extractionDetails) {
        const customEvent = new CustomEvent(event, {
            detail: extractionDetails
        });
        this.dispatchEvent(customEvent);
    }
    #emitError(e) {
        const customErrorEvent = new CustomEvent("error", {
            detail: e
        });
        this.dispatchEvent(customErrorEvent);
    }
}
export const Callbacks = {
    packument(callback) {
        return {
            level: "packument",
            next: callback,
            done: noop
        };
    },
    manifest(callback) {
        return {
            level: "manifest",
            next: callback,
            done: noop
        };
    }
};
function noop() {
    return void 0;
}
//# sourceMappingURL=payload.js.map