vite-plugin-zephyr/dist/lib/vite-plugin-zephyr-partial.js

Vite plugin for Zephyr

"use strict";
var __webpack_require__ = {};
(()=>{
    __webpack_require__.d = (exports1, getters, values)=>{
        var define = (defs, kind)=>{
            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
                enumerable: true,
                [kind]: defs[key]
            });
        };
        define(getters, "get");
        define(values, "value");
    };
})();
(()=>{
    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
})();
(()=>{
    __webpack_require__.r = (exports1)=>{
        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
            value: 'Module'
        });
        Object.defineProperty(exports1, '__esModule', {
            value: true
        });
    };
})();
var __webpack_exports__ = {};
__webpack_require__.r(__webpack_exports__);
__webpack_require__.d(__webpack_exports__, {
    withZephyrPartial: ()=>withZephyrPartial
});
const external_node_path_namespaceObject = require("node:path");
const external_zephyr_agent_namespaceObject = require("zephyr-agent");
const extract_vite_assets_map_js_namespaceObject = require("./internal/extract/extract_vite_assets_map.js");
const partial_build_scope_js_namespaceObject = require("./internal/partial-build-scope.js");
function withZephyrPartial(options = {}) {
    if (void 0 !== options.target) (0, external_zephyr_agent_namespaceObject.assertZephyrBuildTarget)(options.target, 'withZephyrPartial({ target })');
    const { zephyr_engine_defer, zephyr_defer_create } = external_zephyr_agent_namespaceObject.ZephyrEngine.defer_create();
    let partialScope;
    let resolve_vite_internal_options;
    const vite_internal_options_defer = new Promise((resolve)=>{
        resolve_vite_internal_options = resolve;
    });
    return {
        name: 'with-zephyr-partial',
        apply: 'build',
        enforce: 'post',
        configResolved: async (config)=>{
            partialScope = (0, partial_build_scope_js_namespaceObject.requireVitePartialBuildScope)(options);
            zephyr_defer_create({
                builder: 'vite',
                context: config.root,
                target: options.target
            });
            resolve_vite_internal_options({
                root: config.root,
                configFile: config.configFile,
                outDir: config.build.outDir,
                publicDir: config.publicDir,
                target: options.target
            });
        },
        writeBundle: async function(options, bundle) {
            const baseOptions = await vite_internal_options_defer;
            const environmentName = this.environment?.name;
            const outputDir = external_node_path_namespaceObject.resolve(baseOptions.root, options.dir ?? (options.file ? external_node_path_namespaceObject.dirname(options.file) : baseOptions.outDir));
            const vite_internal_options = {
                ...baseOptions,
                dir: options.dir,
                outDir: outputDir,
                assets: bundle
            };
            try {
                if (!partialScope) throw new external_zephyr_agent_namespaceObject.ZephyrError(external_zephyr_agent_namespaceObject.ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
                    message: 'Vite partial build scope was not resolved before writeBundle.'
                });
                const zephyr_engine = await zephyr_engine_defer;
                const application_uid = zephyr_engine.application_uid;
                const assetsMap = await (0, extract_vite_assets_map_js_namespaceObject.extract_vite_assets_map)(zephyr_engine, vite_internal_options);
                await (0, external_zephyr_agent_namespaceObject.savePartialAssetMap)(application_uid, [
                    'vite-partial',
                    vite_internal_options.configFile ?? 'partial',
                    environmentName ?? 'default',
                    outputDir.replace(/\\/g, '/')
                ].join(':'), assetsMap, partialScope);
            } catch (error) {
                (0, external_zephyr_agent_namespaceObject.handleGlobalError)(error);
            }
        }
    };
}
exports.withZephyrPartial = __webpack_exports__.withZephyrPartial;
for(var __rspack_i in __webpack_exports__)if (-1 === [
    "withZephyrPartial"
].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
Object.defineProperty(exports, '__esModule', {
    value: true
});

//# sourceMappingURL=vite-plugin-zephyr-partial.js.map