testeranto 0.129.0 → 0.135.0

package/dist/module/src/build.js

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import ansiC from "ansi-colors";
 import fs from "fs";
 import path from "path";
@@ -11,7 +13,7 @@ import { getRunnables } from "./utils.js";
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY)
     process.stdin.setRawMode(true);
-let testName = process.argv[2];
+const testName = process.argv[2];
 let mode = process.argv[3];
 if (mode !== "once" && mode !== "dev") {
     console.error(`The 4th argument should be 'dev' or 'once', not '${mode}'.`);
@@ -41,6 +43,19 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
         };
         return Array.from(meta(config.tests, new Set()));
     };
+    const getSideCars = (runtime) => {
+        return Array.from(new Set(config.tests
+            .reduce((mm, t) => {
+            mm = mm.concat(t[3]);
+            return mm;
+        }, [])
+            .filter((t) => {
+            return t[1] === runtime;
+        })
+            .map((t) => {
+            return t[0];
+        })));
+    };
     const config = Object.assign(Object.assign({}, rawConfig), { buildDir: process.cwd() + "/testeranto/bundles/" + testName });
     console.log(`Press 'q' to shutdown gracefully. Press 'x' to shutdown forcefully.`);
     process.stdin.on("keypress", (str, key) => {
@@ -61,7 +76,11 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
     let webDone = false;
     let importDone = false;
     let status = "build";
-    const { nodeEntryPoints, webEntryPoints, importEntryPoints } = getRunnables(config.tests, testName);
+    const { nodeEntryPoints, nodeEntryPointSidecars, webEntryPoints, webEntryPointSidecars, pureEntryPoints, pureEntryPointSidecars, } = getRunnables(config.tests, testName);
+    // const { nodeEntryPointsSidecars, webEntryPointsSidecars, importEntryPointsSideCars } = getRunnableSidecars(
+    //   config.tests,
+    //   testName
+    // );
     const onNodeDone = () => {
         nodeDone = true;
         onDone();
@@ -83,6 +102,7 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
             process.exit();
         }
     };
+    console.log(`testeranto/reports/${testName}`);
     if (!fs.existsSync(`testeranto/reports/${testName}`)) {
         fs.mkdirSync(`testeranto/reports/${testName}`);
     }
@@ -121,13 +141,14 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
     <title>${pckge.name} - testeranto</title>
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <meta name="author" content="" />
+    <base href="https://adamwong246.github.io/spacetrash_v8" target="_blank">
 
     <script type="application/json" id="bigConfig">
       ${JSON.stringify(Object.keys(bigConfig.projects))}
     </script>
 
-    <link rel="stylesheet" href="Project.css" />
-    <script type="module" src="Project.js"></script>
+    <link rel="stylesheet" href="/reports/Project.css" />
+    <script type="module" src="/reports/Project.js"></script>
 
   </head>
 
@@ -161,11 +182,24 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
     //   });
     // });
     const x = [
-        ["pure", Object.keys(importEntryPoints)],
+        ["pure", Object.keys(pureEntryPoints)],
         ["node", Object.keys(nodeEntryPoints)],
         ["web", Object.keys(webEntryPoints)],
+        // [
+        //   "pure",
+        //   [...Object.keys(pureEntryPoints), ...Object.keys(pureEntryPointSidecars)],
+        // ],
+        // [
+        //   "node",
+        //   [...Object.keys(nodeEntryPoints), ...Object.keys(nodeEntryPointSidecars)],
+        // ],
+        // [
+        //   "web",
+        //   [...Object.keys(webEntryPoints), ...Object.keys(webEntryPointSidecars)],
+        // ],
     ];
     x.forEach(async ([runtime, keys]) => {
+        console.log(runtime, keys);
         keys.forEach(async (k) => {
             const folder = `testeranto/reports/${testName}/${k
                 .split(".")
@@ -183,8 +217,8 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <meta name="author" content="" />
 
-  <link rel="stylesheet" href="../../../../../TestReport.css" />
-  <script src="../../../../../TestReport.js"></script>
+  <link rel="stylesheet" href="../../../../../../TestReport.css" />
+  <script src="../../../../../../TestReport.js"></script>
 
 </head>
 
@@ -194,14 +228,34 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
             `);
         });
     });
+    [
+        [pureEntryPoints, pureEntryPointSidecars, "pure"],
+        [webEntryPoints, webEntryPointSidecars, "web"],
+        [nodeEntryPoints, nodeEntryPointSidecars, "node"],
+    ].forEach(([eps, eps2, runtime]) => {
+        [...Object.keys(eps), ...Object.keys(eps2)].forEach((ep) => {
+            const fp = path.resolve(`testeranto`, `reports`, testName, ep.split(".").slice(0, -1).join("."), runtime);
+            fs.mkdirSync(fp, { recursive: true });
+        });
+    });
     await Promise.all([
         ...[
-            [esbuildImportConfiger, importEntryPoints, onImportDone],
-            [esbuildNodeConfiger, nodeEntryPoints, onNodeDone],
-            [esbuildWebConfiger, webEntryPoints, onWebDone],
-        ].map(([configer, entryPoints, done]) => {
+            [
+                esbuildImportConfiger,
+                pureEntryPoints,
+                pureEntryPointSidecars,
+                onImportDone,
+            ],
+            [
+                esbuildNodeConfiger,
+                nodeEntryPoints,
+                nodeEntryPointSidecars,
+                onNodeDone,
+            ],
+            [esbuildWebConfiger, webEntryPoints, webEntryPointSidecars, onWebDone],
+        ].map(([configer, entryPoints, sidecars, done]) => {
             esbuild
-                .context(configer(config, Object.keys(entryPoints), testName))
+                .context(configer(config, [...Object.keys(entryPoints), ...Object.keys(sidecars)], testName))
                 .then(async (ctx) => {
                 if (mode === "dev") {
                     await ctx.watch().then((v) => {

package/dist/module/src/defaultConfig.js

@@ -9,6 +9,7 @@ const config = {
     nodePlugins: [],
     webPlugins: [],
     importPlugins: [],
+    externalTests: {},
     featureIngestor: function (s) {
         throw new Error("Function not implemented.");
     },

package/dist/module/src/esbuildConfigs/consoleDetectorPlugin.js

@@ -0,0 +1,24 @@
+export const consoleDetectorPlugin = {
+    name: 'console-detector',
+    setup(build) {
+        build.onLoad({ filter: /\.(js|ts)$/ }, async (args) => {
+            const contents = await require('fs').promises.readFile(args.path, 'utf8');
+            const consolePattern = /console\.(log|error|warn|info|debug|trace|dir|dirxml|table|group|groupEnd|clear|count|countReset|assert|profile|profileEnd|time|timeLog|timeEnd|timeStamp|context|memory)/g;
+            const matches = contents.match(consolePattern);
+            if (matches) {
+                const uniqueMethods = [...new Set(matches)];
+                return {
+                    warnings: uniqueMethods.map(method => ({
+                        text: `Detected ${method} call - Pure runtime does not allow IO operations. Use Node runtime instead.`,
+                        location: {
+                            file: args.path,
+                            line: contents.split('\n').findIndex(line => line.includes(method)) + 1,
+                            column: 0
+                        }
+                    }))
+                };
+            }
+            return null;
+        });
+    }
+};

package/dist/module/src/esbuildConfigs/eslint-formatter-testeranto.js

@@ -1,3 +1,18 @@
 export default function (results) {
-    return JSON.stringify(results, null, 2);
+    return results
+        .filter((r) => r.messages.length)
+        .map((r) => {
+        const path = r.filePath.replace(process.cwd() + "/", "");
+        return [
+            path,
+            ...r.messages.map((m) => {
+                var _a;
+                return [
+                    `${m.line}:${m.column} ${m.message} (${m.ruleId || ""})`,
+                    ...(((_a = m.suggestions) === null || _a === void 0 ? void 0 : _a.map((s) => `- ${s.message}${s.fix ? " (fix)" : ""}`)) || []),
+                ].join("\n");
+            }),
+        ].join("\n");
+    })
+        .join("\n\n");
 }

package/dist/module/src/esbuildConfigs/node.js

@@ -1,6 +1,7 @@
 import baseEsBuildConfig from "./index.js";
 import inputFilesPlugin from "./inputFilesPlugin.js";
 import featuresPlugin from "./featuresPlugin";
+import rebuildPlugin from "./rebuildPlugin.js";
 export default (config, entryPoints, testName) => {
     const { inputFilesPluginFactory, register } = inputFilesPlugin("node", testName);
     return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { splitting: true, outdir: `testeranto/bundles/node/${testName}/`, 
@@ -14,22 +15,7 @@ export default (config, entryPoints, testName) => {
         }, platform: "node", external: ["react", ...config.externals], entryPoints: [...entryPoints], plugins: [
             featuresPlugin,
             inputFilesPluginFactory,
-            {
-                name: "rebuild-notify",
-                setup: (build) => {
-                    build.onStart(() => {
-                        console.log(`> node build starting...`);
-                    });
-                    build.onEnd((result) => {
-                        console.log(`> node build ended with ${result.errors.length} errors`);
-                        if (result.errors.length > 0) {
-                            console.log(result);
-                        }
-                        // console.log(result);
-                        // result.errors.length !== 0 && process.exit(-1);
-                    });
-                },
-            },
+            rebuildPlugin("node"),
             ...(config.nodePlugins.map((p) => p(register, entryPoints)) || []),
         ] });
 };

package/dist/module/src/esbuildConfigs/pure.js

@@ -1,9 +1,12 @@
 import baseEsBuildConfig from "./index.js";
 import inputFilesPlugin from "./inputFilesPlugin.js";
 import featuresPlugin from "./featuresPlugin.js";
+import { isBuiltin } from "node:module";
+import { consoleDetectorPlugin } from "./consoleDetectorPlugin.js";
+import rebuildPlugin from "./rebuildPlugin.js";
 export default (config, entryPoints, testName) => {
     const { inputFilesPluginFactory, register } = inputFilesPlugin("pure", testName);
-    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { drop: ["console", "debugger"], splitting: true, outdir: `testeranto/bundles/pure/${testName}/`, 
+    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { drop: [], splitting: true, outdir: `testeranto/bundles/pure/${testName}/`, 
         // inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
         metafile: true, supported: {
             "dynamic-import": true,
@@ -14,22 +17,19 @@ export default (config, entryPoints, testName) => {
         }, platform: "node", external: ["react", ...config.externals], entryPoints: [...entryPoints], plugins: [
             featuresPlugin,
             inputFilesPluginFactory,
+            consoleDetectorPlugin,
             {
-                name: "rebuild-notify",
-                setup: (build) => {
-                    build.onStart(() => {
-                        console.log(`> pure build starting...`);
-                    });
-                    build.onEnd((result) => {
-                        console.log(`> pure build ended with ${result.errors.length} errors`);
-                        if (result.errors.length > 0) {
-                            console.log(result);
+                name: "native-node-import-filter",
+                setup(build) {
+                    build.onResolve({ filter: /fs/ }, (args) => {
+                        if (isBuiltin(args.path)) {
+                            throw new Error(`cannot use native node package "${args.path}" in a "pure" test. If you really want to use this package, convert this test from "pure" to "node"`);
                         }
-                        // console.log(result);
-                        // result.errors.length !== 0 && process.exit(-1);
+                        return { path: args.path };
                     });
                 },
             },
+            rebuildPlugin("pure"),
             ...((config.nodePlugins || []).map((p) => p(register, entryPoints)) ||
                 []),
         ] });

package/dist/module/src/esbuildConfigs/rebuildPlugin.js

@@ -0,0 +1,17 @@
+import fs from "fs";
+export default (r) => {
+    return {
+        name: "rebuild-notify",
+        setup: (build) => {
+            build.onStart(() => {
+                console.log(`> web build starting...`);
+            });
+            build.onEnd((result) => {
+                console.log(`> web build ended with ${result.errors.length} errors`);
+                if (result.errors.length > 0) {
+                    fs.writeFileSync(`./testeranto/reports${r}_build_errors`, JSON.stringify(result, null, 2));
+                }
+            });
+        },
+    };
+};

package/dist/module/src/esbuildConfigs/web.js

@@ -1,10 +1,12 @@
+import { polyfillNode } from "esbuild-plugin-polyfill-node";
 import path from "path";
 import baseEsBuildConfig from "./index.js";
 import inputFilesPlugin from "./inputFilesPlugin.js";
 import featuresPlugin from "./featuresPlugin.js";
+import rebuildPlugin from "./rebuildPlugin.js";
 export default (config, entryPoints, testName) => {
     const { inputFilesPluginFactory, register } = inputFilesPlugin("web", testName);
-    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { outdir: `testeranto/bundles/web/${testName}`, alias: {
+    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { treeShaking: true, outdir: `testeranto/bundles/web/${testName}`, alias: {
             react: path.resolve("./node_modules/react"),
         }, metafile: true, external: [
             "path",
@@ -27,22 +29,15 @@ export default (config, entryPoints, testName) => {
         ], platform: "browser", entryPoints: [...entryPoints], plugins: [
             featuresPlugin,
             inputFilesPluginFactory,
-            {
-                name: "rebuild-notify",
-                setup: (build) => {
-                    build.onStart(() => {
-                        console.log(`> web build starting...`);
-                    });
-                    build.onEnd((result) => {
-                        console.log(`> web build ended with ${result.errors.length} errors`);
-                        if (result.errors.length > 0) {
-                            console.log(result);
-                        }
-                        // console.log(result);
-                        // result.errors.length !== 0 && process.exit(-1);
-                    });
-                },
-            },
+            polyfillNode({
+            // You might need to configure specific Node.js modules you want to polyfill
+            // Example:
+            // modules: {
+            //   'util': true,
+            //   'fs': false,
+            // }
+            }),
+            rebuildPlugin("web"),
             ...((config.webPlugins || []).map((p) => p(register, entryPoints)) || []),
         ] });
 };

package/dist/module/src/lib/Sidecar.js

@@ -0,0 +1,2 @@
+export class Sidecar {
+}

package/dist/module/src/lib/abstractBase.js

@@ -54,7 +54,7 @@ export class BaseSuite {
             catch (e) {
                 this.failed = true;
                 this.fails = this.fails + 1;
-                // console.error(e);
+                console.error(e);
                 // this.fails.push(giver);
                 // return this;
             }
@@ -101,7 +101,12 @@ export class BaseGiven {
         return {
             key: this.key,
             name: this.name,
-            whens: this.whens.map((w) => w.toObj()),
+            whens: this.whens.map((w) => {
+                if (w && w.toObj)
+                    return w.toObj();
+                console.error("w is not as expected!", w);
+                return {};
+            }),
             thens: this.thens.map((t) => t.toObj()),
             error: this.error ? [this.error, this.error.stack] : null,
             failed: this.failed,
@@ -136,7 +141,7 @@ export class BaseGiven {
             }
             for (const [thenNdx, thenStep] of this.thens.entries()) {
                 const t = await thenStep.test(this.store, testResourceConfiguration, tLog, pm, `suite-${suiteNdx}/given-${key}/then-${thenNdx}`);
-                return tester(t);
+                tester(t);
                 // ((t) => {
                 //   return tester(t);
                 // })();
@@ -167,16 +172,18 @@ export class BaseWhen {
         this.whenCB = whenCB;
     }
     toObj() {
+        console.log("toObj error", this.error);
         return {
             name: this.name,
-            error: this.error,
+            error: this.error && this.error.name + this.error.stack,
         };
     }
     async test(store, testResourceConfiguration, tLog, pm, filepath) {
         tLog(" When:", this.name);
         return await this.andWhen(store, this.whenCB, testResourceConfiguration, andWhenProxy(pm, filepath)).catch((e) => {
-            this.error = true;
-            // throw e;
+            console.log("MARK9", e);
+            this.error = e;
+            throw e;
         });
     }
 }

package/dist/module/src/lib/basebuilder.js

@@ -25,15 +25,13 @@ export class BaseBuilder {
                 },
                 runner,
                 receiveTestResourceConfig: async function (puppetMaster) {
-                    const start = await puppetMaster.start();
                     const logFilePath = "log.txt";
                     const access = await puppetMaster.createWriteStream(logFilePath);
                     const tLog = async (...l) => {
-                        const x = await puppetMaster.write(access, `${l.toString()}\n`);
                         // console.log("x", x);
                     };
                     const suiteDone = await runner(puppetMaster, tLog);
-                    const logPromise = new Promise(async (res, rej) => {
+                    const logPromise = new Promise(async (res) => {
                         await puppetMaster.end(access);
                         res(true);
                     });

package/dist/module/src/lib/classBuilder.js

@@ -8,34 +8,20 @@ export class ClassBuilder extends BaseBuilder {
             return a;
         }, {});
         const classyGivens = Object.entries(testImplementation.givens).reduce((a, [key, g]) => {
-            a[key] = (features, whens, thens) => {
-                // console.log("givEn", givEn.toString());
-                return new givenKlasser.prototype.constructor(key, features, whens, thens, testImplementation.givens[key]
-                // givEn
-                );
+            a[key] = (features, whens, thens, ...initialValues) => {
+                return new givenKlasser.prototype.constructor(key, features, whens, thens, testImplementation.givens[key], initialValues);
             };
             return a;
         }, {});
         const classyWhens = Object.entries(testImplementation.whens).reduce((a, [key, whEn]) => {
-            a[key] = (payload) => {
-                return new whenKlasser.prototype.constructor(`${whEn.name}: ${payload && payload.toString()}`, whEn(payload));
+            a[key] = (...payload) => {
+                return new whenKlasser.prototype.constructor(`${whEn.name}: ${payload && payload.toString()}`, whEn(...payload));
             };
             return a;
         }, {});
         const classyThens = Object.entries(testImplementation.thens).reduce((a, [key, thEn]) => {
-            a[key] = (expected, x) => {
-                return new thenKlasser.prototype.constructor(`${thEn.name}: ${expected && expected.toString()}`, 
-                // () => {
-                //   thEn(expected);
-                //   // return new Promise((res), rej) => {
-                //   // }
-                //   // try {
-                //   //   thEn(expected);
-                //   // } catch (c) {
-                //   //   console.log("mark99");
-                //   // }
-                // },
-                thEn(expected));
+            a[key] = (expected, ...x) => {
+                return new thenKlasser.prototype.constructor(`${thEn.name}: ${expected && expected.toString()}`, thEn(expected, ...x));
             };
             return a;
         }, {});

package/dist/module/src/lib/core.js

@@ -30,12 +30,17 @@ export default class Testeranto extends ClassBuilder {
             }
         }, class When extends BaseWhen {
             async andWhen(store, whenCB, testResource, pm) {
-                try {
-                    return await fullTestInterface.andWhen(store, whenCB, testResource, pm);
-                }
-                catch (e) {
-                    throw e;
-                }
+                return await fullTestInterface.andWhen(store, whenCB, testResource, pm);
+                // try {
+                //   return await fullTestInterface.andWhen(
+                //     store,
+                //     whenCB,
+                //     testResource,
+                //     pm
+                //   );
+                // } catch (e) {
+                //   console.log("mark22", e);
+                // }
             }
         }, class Then extends BaseThen {
             async butThen(store, thenCB, testResource, pm) {

package/dist/module/src/lib/index.js

@@ -1,4 +1,4 @@
-export const BaseTestInterface = {
+export const BaseTestInterface = () => ({
     beforeAll: async (s) => s,
     beforeEach: async function (subject, initialValues, x, testResource, pm) {
         return subject;
@@ -8,9 +8,17 @@ export const BaseTestInterface = {
     butThen: async (store, thenCb) => {
         return thenCb(store);
     },
-    andWhen: async (a) => a,
-    assertThis: (x) => null,
-};
+    andWhen: async (store, whenCB, testResource, pm) => {
+        try {
+            await whenCB(store, testResource, pm);
+        }
+        catch (error) {
+            console.error("Error in andWhen:", error);
+            throw error; // Re-throw to maintain test failure
+        }
+    },
+    assertThis: (x) => x,
+});
 export const DefaultTestInterface = (p) => {
     return Object.assign(Object.assign({}, BaseTestInterface), p);
 };

package/dist/module/src/lib/pmProxy.js

@@ -5,7 +5,7 @@ const prxy = function (pm, mappings) {
                 const method = mapping[0];
                 const arger = mapping[1];
                 if (prop === method) {
-                    return (x) => target[prop](arger(x));
+                    return (...x) => target[prop](arger(...x));
                 }
             }
             return (...x) => target[prop](...x);

package/dist/module/src/mothership/index.js

@@ -0,0 +1,11 @@
+import express from "express";
+const app = express();
+app.get("/", (req, res) => {
+    res.send("Hello World!");
+});
+export default (port) => {
+    app.listen(port, () => {
+        console.log(`Example app listening on port ${port}`);
+    });
+    return app;
+};

package/dist/module/src/mothership/test.js

@@ -0,0 +1,60 @@
+import Testeranto from "../Node";
+import appFactory from "./index";
+const specification = (Suite, Given, When, Then) => {
+    console.log("Suite", Suite);
+    return [
+        Suite.TheMothership("the mothership allows the coordination of test resources", {
+            test0: Given.ItIsRunning([`a resource can be claimed`], [When.IClaimTheResource("test")], [
+            // Then.TheResourceIsClaimed("test")
+            ]),
+        }, []),
+    ];
+};
+const implementation = {
+    suites: { TheMothership: (x) => x },
+    givens: { ItIsRunning: () => undefined },
+    whens: {
+        IClaimTheResource: (resource) => async (i, tr, p) => {
+            fetch(`http://localhost:${tr.ports[0]}/claim?${resource}`);
+        },
+        IReleaseTheResource: function (resource) {
+            throw new Error("Function not implemented.");
+        },
+        IResetTheResource: function (Iw_0) {
+            throw new Error("Function not implemented.");
+        },
+    },
+    thens: {
+        TheResourceIsClaimed: (resource) => async (z, u) => {
+            throw new Error("Function not implemented.");
+        },
+        TheResourceIsUnClaimed: function (It_0) {
+            throw new Error("Function not implemented.");
+        },
+    },
+    checks: { AnEmptyState: () => "any" },
+};
+const testInterface = {
+    // assertThis: function (x: any) {
+    //   throw new Error("Function not implemented.");
+    // },
+    // andWhen: function (store: any, whenCB: any, testResource: ITTestResourceConfiguration, pm: IPM): Promise<any> {
+    //   throw new Error("Function not implemented.");
+    // },
+    // butThen: function (store: any, thenCB: any, testResource: ITTestResourceConfiguration, pm: IPM): Promise<any> {
+    //   throw new Error("Function not implemented.");
+    // },
+    // afterAll: function (store: any, pm: IPM) {
+    //   throw new Error("Function not implemented.");
+    // },
+    // afterEach: function (store: any, key: string, pm: IPM): Promise<unknown> {
+    //   throw new Error("Function not implemented.");
+    // },
+    // beforeAll: function (input: Express, testResource: ITTestResourceConfiguration, pm: IPM): Promise<any> {
+    //   throw new Error("Function not implemented.");
+    // },
+    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+        return subject(testResource.ports[0]);
+    },
+};
+export default Testeranto(appFactory, specification, implementation, testInterface);

package/dist/module/src/utils/queue.js

@@ -0,0 +1,32 @@
+export class Queue {
+    constructor() {
+        this.items = [];
+    }
+    enqueue(element) {
+        this.items.push(element);
+    }
+    dequeue() {
+        if (this.isEmpty()) {
+            return "Queue is empty";
+        }
+        return this.items.shift();
+    }
+    peek() {
+        if (this.isEmpty()) {
+            return "Queue is empty";
+        }
+        return this.items[0];
+    }
+    isEmpty() {
+        return this.items.length === 0;
+    }
+    size() {
+        return this.items.length;
+    }
+    clear() {
+        this.items = [];
+    }
+    print() {
+        console.log(this.items.join(" -> "));
+    }
+}