@tachybase/plugin-print-template 0.23.8

package/.turbo/turbo-build.log

@@ -0,0 +1,14 @@
+
+
+> @tachybase/plugin-print-template@0.23.7 build /Users/seal/Documents/projects/tachybase/packages/plugin-prototype-print-template
+> tachybase-build --no-dts @tachybase/plugin-print-template
+
+The CJS build of Vite's Node API is deprecated. See https://vite.dev/guide/troubleshooting.html#vite-cjs-node-api-deprecated for more details.
+@tachybase/plugin-print-template: plugin-prototype-print-template build start
+@tachybase/plugin-print-template: build plugin client
+@tachybase/plugin-print-template: build plugin server source
+@tachybase/plugin-print-template: delete server files
+@tachybase/plugin-print-template: build plugin server dependencies
+@tachybase/plugin-print-template: These packages bullmq, docxtemplater, pizzip will be bundled to dist/node_modules. These packages @tachybase/database, @tachybase/server, koa-bodyparser, @tachybase/actions will be exclude.
+@tachybase/plugin-print-template: write external version
+

package/README.md

@@ -0,0 +1 @@
+# @tachybase/plugin-print-template

package/client.d.ts

@@ -0,0 +1,2 @@
+export * from './dist/client';
+export { default } from './dist/client';

package/client.js

@@ -0,0 +1 @@
+module.exports = require('./dist/client/index.js');

package/dist/client/index.d.ts

@@ -0,0 +1,7 @@
+import { Plugin } from '@tachybase/client';
+export declare class PluginPrintTemplateClient extends Plugin {
+    afterAdd(): Promise<void>;
+    beforeLoad(): Promise<void>;
+    load(): Promise<void>;
+}
+export default PluginPrintTemplateClient;

package/dist/client/index.js

@@ -0,0 +1 @@
+(function(e,t){typeof exports=="object"&&typeof module!="undefined"?t(exports,require("@tachybase/client")):typeof define=="function"&&define.amd?define(["exports","@tachybase/client"],t):(e=typeof globalThis!="undefined"?globalThis:e||self,t(e["@tachybase/plugin-print-template"]={},e["@tachybase/client"]))})(this,function(e,t){"use strict";var l=(e,t,n)=>new Promise((d,o)=>{var u=i=>{try{a(n.next(i))}catch(s){o(s)}},c=i=>{try{a(n.throw(i))}catch(s){o(s)}},a=i=>i.done?d(i.value):Promise.resolve(i.value).then(u,c);a((n=n.apply(e,t)).next())});class n extends t.Plugin{afterAdd(){return l(this,null,function*(){})}beforeLoad(){return l(this,null,function*(){})}load(){return l(this,null,function*(){console.log(this.app)})}}e.PluginPrintTemplateClient=n,e.default=n,Object.defineProperties(e,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})});

package/dist/externalVersion.js

@@ -0,0 +1,7 @@
+module.exports = {
+  "@tachybase/client": "0.23.8",
+  "@tachybase/database": "0.23.8",
+  "@tachybase/server": "0.23.8",
+  "koa-bodyparser": "4.4.1",
+  "@tachybase/actions": "0.23.8"
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './server';
+export { default } from './server';

package/dist/index.js

@@ -0,0 +1,39 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  default: () => import_server.default
+});
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./server"), module.exports);
+var import_server = __toESM(require("./server"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./server")
+});

package/dist/node_modules/bullmq/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 BullForce Labs AB.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/node_modules/bullmq/dist/cjs/classes/async-fifo-queue.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncFifoQueue = void 0;
+class Node {
+    constructor(value) {
+        this.value = undefined;
+        this.next = null;
+        this.value = value;
+    }
+}
+class LinkedList {
+    constructor() {
+        this.length = 0;
+        this.head = null;
+        this.tail = null;
+    }
+    push(value) {
+        const newNode = new Node(value);
+        if (!this.length) {
+            this.head = newNode;
+        }
+        else {
+            this.tail.next = newNode;
+        }
+        this.tail = newNode;
+        this.length += 1;
+        return newNode;
+    }
+    shift() {
+        if (!this.length) {
+            return null;
+        }
+        else {
+            const head = this.head;
+            this.head = this.head.next;
+            this.length -= 1;
+            return head;
+        }
+    }
+}
+/**
+ * AsyncFifoQueue
+ *
+ * A minimal FIFO queue for asynchronous operations. Allows adding asynchronous operations
+ * and consume them in the order they are resolved.
+ */
+class AsyncFifoQueue {
+    constructor(ignoreErrors = false) {
+        this.ignoreErrors = ignoreErrors;
+        /**
+         * A queue of completed promises. As the pending
+         * promises are resolved, they are added to this queue.
+         */
+        this.queue = new LinkedList();
+        /**
+         * A set of pending promises.
+         */
+        this.pending = new Set();
+        this.newPromise();
+    }
+    add(promise) {
+        this.pending.add(promise);
+        promise
+            .then(data => {
+            this.pending.delete(promise);
+            if (this.queue.length === 0) {
+                this.resolvePromise(data);
+            }
+            this.queue.push(data);
+        })
+            .catch(err => {
+            // Ignore errors
+            if (this.ignoreErrors) {
+                this.queue.push(undefined);
+            }
+            this.pending.delete(promise);
+            this.rejectPromise(err);
+        });
+    }
+    async waitAll() {
+        await Promise.all(this.pending);
+    }
+    numTotal() {
+        return this.pending.size + this.queue.length;
+    }
+    numPending() {
+        return this.pending.size;
+    }
+    numQueued() {
+        return this.queue.length;
+    }
+    resolvePromise(data) {
+        this.resolve(data);
+        this.newPromise();
+    }
+    rejectPromise(err) {
+        this.reject(err);
+        this.newPromise();
+    }
+    newPromise() {
+        this.nextPromise = new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+    }
+    async wait() {
+        return this.nextPromise;
+    }
+    async fetch() {
+        var _a;
+        if (this.pending.size === 0 && this.queue.length === 0) {
+            return;
+        }
+        while (this.queue.length === 0) {
+            try {
+                await this.wait();
+            }
+            catch (err) {
+                // Ignore errors
+                if (!this.ignoreErrors) {
+                    console.error('Unexpected Error in AsyncFifoQueue', err);
+                }
+            }
+        }
+        return (_a = this.queue.shift()) === null || _a === void 0 ? void 0 : _a.value;
+    }
+}
+exports.AsyncFifoQueue = AsyncFifoQueue;
+//# sourceMappingURL=async-fifo-queue.js.map

package/dist/node_modules/bullmq/dist/cjs/classes/backoffs.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Backoffs = void 0;
+class Backoffs {
+    static normalize(backoff) {
+        if (Number.isFinite(backoff)) {
+            return {
+                type: 'fixed',
+                delay: backoff,
+            };
+        }
+        else if (backoff) {
+            return backoff;
+        }
+    }
+    static calculate(backoff, attemptsMade, err, job, customStrategy) {
+        if (backoff) {
+            const strategy = lookupStrategy(backoff, customStrategy);
+            return strategy(attemptsMade, backoff.type, err, job);
+        }
+    }
+}
+exports.Backoffs = Backoffs;
+Backoffs.builtinStrategies = {
+    fixed: function (delay) {
+        return function () {
+            return delay;
+        };
+    },
+    exponential: function (delay) {
+        return function (attemptsMade) {
+            return Math.round(Math.pow(2, attemptsMade - 1) * delay);
+        };
+    },
+};
+function lookupStrategy(backoff, customStrategy) {
+    if (backoff.type in Backoffs.builtinStrategies) {
+        return Backoffs.builtinStrategies[backoff.type](backoff.delay);
+    }
+    else if (customStrategy) {
+        return customStrategy;
+    }
+    else {
+        throw new Error(`Unknown backoff strategy ${backoff.type}.
+      If a custom backoff strategy is used, specify it when the queue is created.`);
+    }
+}
+//# sourceMappingURL=backoffs.js.map

package/dist/node_modules/bullmq/dist/cjs/classes/child-pool.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChildPool = void 0;
+const path = require("path");
+const child_1 = require("./child");
+const CHILD_KILL_TIMEOUT = 30000;
+class ChildPool {
+    constructor({ mainFile = path.join(process.cwd(), 'dist/cjs/classes/main.js'), useWorkerThreads, workerForkOptions, workerThreadsOptions, }) {
+        this.retained = {};
+        this.free = {};
+        this.opts = {
+            mainFile,
+            useWorkerThreads,
+            workerForkOptions,
+            workerThreadsOptions,
+        };
+    }
+    async retain(processFile, exitHandler) {
+        let child = this.getFree(processFile).pop();
+        if (child) {
+            this.retained[child.pid] = child;
+            return child;
+        }
+        child = new child_1.Child(this.opts.mainFile, processFile, {
+            useWorkerThreads: this.opts.useWorkerThreads,
+            workerForkOptions: this.opts.workerForkOptions,
+            workerThreadsOptions: this.opts.workerThreadsOptions,
+        });
+        child.on('exit', exitHandler);
+        try {
+            await child.init();
+            this.retained[child.pid] = child;
+            return child;
+        }
+        catch (err) {
+            console.error(err);
+            this.release(child);
+            throw err;
+        }
+    }
+    release(child) {
+        delete this.retained[child.pid];
+        this.getFree(child.processFile).push(child);
+    }
+    remove(child) {
+        delete this.retained[child.pid];
+        const free = this.getFree(child.processFile);
+        const childIndex = free.indexOf(child);
+        if (childIndex > -1) {
+            free.splice(childIndex, 1);
+        }
+    }
+    async kill(child, signal = 'SIGKILL') {
+        this.remove(child);
+        return child.kill(signal, CHILD_KILL_TIMEOUT);
+    }
+    async clean() {
+        const children = Object.values(this.retained).concat(this.getAllFree());
+        this.retained = {};
+        this.free = {};
+        await Promise.all(children.map(c => this.kill(c, 'SIGTERM')));
+    }
+    getFree(id) {
+        return (this.free[id] = this.free[id] || []);
+    }
+    getAllFree() {
+        return Object.values(this.free).reduce((first, second) => first.concat(second), []);
+    }
+}
+exports.ChildPool = ChildPool;
+//# sourceMappingURL=child-pool.js.map

package/dist/node_modules/bullmq/dist/cjs/classes/child-processor.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChildProcessor = void 0;
+const enums_1 = require("../enums");
+const utils_1 = require("../utils");
+var ChildStatus;
+(function (ChildStatus) {
+    ChildStatus[ChildStatus["Idle"] = 0] = "Idle";
+    ChildStatus[ChildStatus["Started"] = 1] = "Started";
+    ChildStatus[ChildStatus["Terminating"] = 2] = "Terminating";
+    ChildStatus[ChildStatus["Errored"] = 3] = "Errored";
+})(ChildStatus || (ChildStatus = {}));
+/**
+ * ChildProcessor
+ *
+ * This class acts as the interface between a child process and it parent process
+ * so that jobs can be processed in different processes.
+ *
+ */
+class ChildProcessor {
+    constructor(send) {
+        this.send = send;
+    }
+    async init(processorFile) {
+        let processor;
+        try {
+            const { default: processorFn } = await import(processorFile);
+            processor = processorFn;
+            if (processor.default) {
+                // support es2015 module.
+                processor = processor.default;
+            }
+            if (typeof processor !== 'function') {
+                throw new Error('No function is exported in processor file');
+            }
+        }
+        catch (err) {
+            this.status = ChildStatus.Errored;
+            return this.send({
+                cmd: enums_1.ParentCommand.InitFailed,
+                err: (0, utils_1.errorToJSON)(err),
+            });
+        }
+        const origProcessor = processor;
+        processor = function (job, token) {
+            try {
+                return Promise.resolve(origProcessor(job, token));
+            }
+            catch (err) {
+                return Promise.reject(err);
+            }
+        };
+        this.processor = processor;
+        this.status = ChildStatus.Idle;
+        await this.send({
+            cmd: enums_1.ParentCommand.InitCompleted,
+        });
+    }
+    async start(jobJson, token) {
+        if (this.status !== ChildStatus.Idle) {
+            return this.send({
+                cmd: enums_1.ParentCommand.Error,
+                err: (0, utils_1.errorToJSON)(new Error('cannot start a not idling child process')),
+            });
+        }
+        this.status = ChildStatus.Started;
+        this.currentJobPromise = (async () => {
+            try {
+                const job = this.wrapJob(jobJson, this.send);
+                const result = await this.processor(job, token);
+                await this.send({
+                    cmd: enums_1.ParentCommand.Completed,
+                    value: typeof result === 'undefined' ? null : result,
+                });
+            }
+            catch (err) {
+                await this.send({
+                    cmd: enums_1.ParentCommand.Failed,
+                    value: (0, utils_1.errorToJSON)(!err.message ? new Error(err) : err),
+                });
+            }
+            finally {
+                this.status = ChildStatus.Idle;
+                this.currentJobPromise = undefined;
+            }
+        })();
+    }
+    async stop() { }
+    async waitForCurrentJobAndExit() {
+        this.status = ChildStatus.Terminating;
+        try {
+            await this.currentJobPromise;
+        }
+        finally {
+            process.exit(process.exitCode || 0);
+        }
+    }
+    /**
+     * Enhance the given job argument with some functions
+     * that can be called from the sandboxed job processor.
+     *
+     * Note, the `job` argument is a JSON deserialized message
+     * from the main node process to this forked child process,
+     * the functions on the original job object are not in tact.
+     * The wrapped job adds back some of those original functions.
+     */
+    wrapJob(job, send) {
+        const wrappedJob = Object.assign(Object.assign({}, job), { data: JSON.parse(job.data || '{}'), opts: job.opts, returnValue: JSON.parse(job.returnvalue || '{}'), 
+            /*
+             * Emulate the real job `updateProgress` function, should works as `progress` function.
+             */
+            async updateProgress(progress) {
+                // Locally store reference to new progress value
+                // so that we can return it from this process synchronously.
+                this.progress = progress;
+                // Send message to update job progress.
+                await send({
+                    cmd: enums_1.ParentCommand.Progress,
+                    value: progress,
+                });
+            }, 
+            /*
+             * Emulate the real job `log` function.
+             */
+            log: async (row) => {
+                await send({
+                    cmd: enums_1.ParentCommand.Log,
+                    value: row,
+                });
+            }, 
+            /*
+             * Emulate the real job `moveToDelayed` function.
+             */
+            moveToDelayed: async (timestamp, token) => {
+                await send({
+                    cmd: enums_1.ParentCommand.MoveToDelayed,
+                    value: { timestamp, token },
+                });
+            }, 
+            /*
+             * Emulate the real job `updateData` function.
+             */
+            updateData: async (data) => {
+                await send({
+                    cmd: enums_1.ParentCommand.Update,
+                    value: data,
+                });
+                wrappedJob.data = data;
+            } });
+        return wrappedJob;
+    }
+}
+exports.ChildProcessor = ChildProcessor;
+//# sourceMappingURL=child-processor.js.map