zephyr-agent/dist/lib/node-persist/atomic-file.js

Zephyr plugin agent

"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__, {
    writeFileAtomically: ()=>writeFileAtomically
});
const external_node_crypto_namespaceObject = require("node:crypto");
const promises_namespaceObject = require("node:fs/promises");
const external_node_path_namespaceObject = require("node:path");
async function syncDirectory(directory) {
    let handle;
    try {
        handle = await (0, promises_namespaceObject.open)(directory, 'r');
        await handle.sync();
    } catch (error) {
        const code = error?.code;
        if (![
            'EACCES',
            'EBADF',
            'EISDIR',
            'EINVAL',
            'EPERM'
        ].includes(code ?? '')) throw error;
    } finally{
        await handle?.close();
    }
}
async function writeFileAtomically(destinationPath, content, hooks = {}) {
    const directory = external_node_path_namespaceObject.dirname(destinationPath);
    await (0, promises_namespaceObject.mkdir)(directory, {
        recursive: true
    });
    const temporaryPath = `${destinationPath}.${process.pid}.${(0, external_node_crypto_namespaceObject.randomUUID)()}.tmp`;
    let handle;
    try {
        handle = await (0, promises_namespaceObject.open)(temporaryPath, 'wx', 384);
        await handle.writeFile(content, 'utf8');
        await handle.sync();
        await handle.close();
        handle = void 0;
        await hooks.beforeRename?.(temporaryPath, destinationPath);
        await (0, promises_namespaceObject.rename)(temporaryPath, destinationPath);
        await syncDirectory(directory);
    } catch (error) {
        await handle?.close().catch(()=>void 0);
        await (0, promises_namespaceObject.rm)(temporaryPath, {
            force: true
        }).catch(()=>void 0);
        throw error;
    }
}
exports.writeFileAtomically = __webpack_exports__.writeFileAtomically;
for(var __rspack_i in __webpack_exports__)if (-1 === [
    "writeFileAtomically"
].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
Object.defineProperty(exports, '__esModule', {
    value: true
});

//# sourceMappingURL=atomic-file.js.map