@ptkl/toolkit 0.3.0

package/dist/playground.js

@@ -0,0 +1,171 @@
+import { existsSync, readdirSync, readFileSync, writeFileSync } from "fs";
+import chokidar from "chokidar";
+import { join, relative } from "path";
+import Builder, { BuildError } from "./builder/index.js";
+import { WebSocketServer } from "ws";
+export default class Playground {
+    apptype;
+    basePath;
+    sdkVersion;
+    engine;
+    profile;
+    watcher;
+    wss;
+    srcPath;
+    connectedClient;
+    constructor(apptype, basePath, sdkVersion, engine, port, profile) {
+        this.apptype = apptype;
+        this.basePath = basePath;
+        this.sdkVersion = sdkVersion;
+        this.engine = engine;
+        this.profile = profile;
+        this.wss = new WebSocketServer({ port });
+        console.log(`Starting playground at ${port}`);
+        console.log(`SDK Version: ${this.sdkVersion}`);
+        console.log(`Engine: ${this.engine}`);
+        this.watcher = chokidar.watch([], { persistent: true, ignoreInitial: true });
+        this.srcPath = "";
+    }
+    async build(files) {
+        console.log("Building app...");
+        const builder = new Builder(this.sdkVersion, this.engine);
+        let dist = await builder.build(files);
+        return dist;
+    }
+    setBuildDetails(manifestFile) {
+        try {
+            const manifest = JSON.parse(readFileSync(manifestFile, "utf-8"));
+            const sdkVersion = manifest?.sdkVersion ? Number(manifest.sdkVersion) : undefined;
+            this.sdkVersion = Number.isInteger(sdkVersion) ? sdkVersion : undefined;
+            this.engine = manifest?.engine;
+        }
+        catch {
+            throw new Error("Unable to read the manifest file, it may be invalid or malformed.");
+        }
+    }
+    setManifestDetails(manifestFile) {
+        try {
+            const manifest = JSON.parse(readFileSync(manifestFile, "utf-8"));
+            const sdkVersion = Number(this.sdkVersion) ? this.sdkVersion : false;
+            const engine = this.engine ? this.engine : false;
+            manifest.sdkVersion = sdkVersion;
+            manifest.engine = engine;
+            writeFileSync(manifestFile, JSON.stringify(manifest, null, 4));
+        }
+        catch (err) {
+            throw new Error(`Unable to set (sdkVersion/engine) in the manifest file: ${err.message}`);
+        }
+    }
+    // Method to validate a given path
+    validatePath(path, createIfNotExist) {
+        if (!existsSync(path)) {
+            if (createIfNotExist) {
+                writeFileSync(path, "{}");
+                this.setManifestDetails(path);
+            }
+            else {
+                throw new Error(`Path does not exist: ${path}`);
+            }
+        }
+        console.log(`Validated path: ${path}`);
+    }
+    async getFilesContents(dir) {
+        const files = readdirSync(dir, { recursive: true, withFileTypes: true });
+        let filesData = {};
+        const ps = files.map(async (file) => {
+            let filePath = join(file.path, file.name);
+            if (file.isFile()) {
+                const p = relative(dir, filePath).replaceAll("\\", "/");
+                filesData[p] = readFileSync(filePath, "utf8");
+            }
+        });
+        await Promise.all(ps);
+        return filesData;
+    }
+    async auth(ws) {
+        ws.send(JSON.stringify({ action: "auth", profile: this.profile }));
+    }
+    async initalWsSend(ws) {
+        try {
+            let initialFilesContents = await this.getFilesContents(this.srcPath);
+            let dist = await this.build(initialFilesContents);
+            if (dist) {
+                ws.send(JSON.stringify({ action: "update", sdkVersion: this.sdkVersion, engine: this.engine, dist }));
+                console.log(`Full build for engine ${this.engine} sdkVersion ${this.sdkVersion}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof BuildError) {
+                error.errors.forEach(err => {
+                    console.error(err);
+                });
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    // Method to validate paths and initialize the watcher
+    init() {
+        const srcDir = join(this.basePath, "src");
+        const manifestFile = join(this.basePath, "manifest.json");
+        this.validatePath(srcDir, false);
+        this.validatePath(manifestFile, true);
+        this.srcPath = srcDir;
+        if (this.engine || this.sdkVersion) {
+            this.setManifestDetails(manifestFile);
+        }
+        this.setBuildDetails(manifestFile);
+    }
+    // Start watching and listen for events
+    start() {
+        this.watcher.add(this.srcPath);
+        this.wss.on("connection", async (ws) => {
+            this.connectedClient = ws;
+            if (this.apptype == 'public-app') {
+                await this.auth(this.connectedClient);
+            }
+            this.initalWsSend(this.connectedClient);
+            console.log("Playground connected");
+        });
+        const handleUpdate = async (filePath) => {
+            try {
+                const fileData = readFileSync(filePath, "utf-8");
+                const relativeFilePath = relative(this.srcPath, filePath);
+                let dist = await this.build({ [relativeFilePath]: fileData });
+                if (dist) {
+                    this.connectedClient.send(JSON.stringify({ action: "update", dist }));
+                    console.log(`Updating ${relativeFilePath}`);
+                }
+                this.watcher.on("add", this.debounce(handleUpdate, 300, false));
+                this.watcher.on("change", this.debounce(handleUpdate, 300, false));
+                this.watcher.on("unlink", this.debounce((filePath) => {
+                    const relativeFilePath = relative(this.srcPath, filePath);
+                    this.connectedClient.send(JSON.stringify({ action: "delete", files: [relativeFilePath] }));
+                    console.log(`Deleting ${relativeFilePath}`);
+                }, 300, false));
+            }
+            catch (err) {
+                console.log(err.message);
+            }
+        };
+    }
+    close() {
+        this.watcher.close();
+        console.log("Watcher closed.");
+    }
+    debounce(func, wait, immediate) {
+        let timeout;
+        return function (...args) {
+            const callNow = immediate && !timeout;
+            clearTimeout(timeout);
+            timeout = setTimeout(() => {
+                timeout = null;
+                if (!immediate)
+                    func.apply(null, args);
+            }, wait);
+            if (callNow)
+                func.apply(null, args);
+        };
+    }
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@ptkl/toolkit",
+  "version": "0.3.0",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "npx tsc",
+    "toolkit": "tsc --build && node dist/bin/toolkit"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "description": "",
+  "dependencies": {
+    "@types/axios": "^0.14.0",
+    "@types/commander": "^2.12.2",
+    "@types/js-yaml": "^4.0.9",
+    "axios": "^1.7.4",
+    "chalk": "^4.1.2",
+    "chokidar": "^4.0.1",
+    "circular-json": "^0.5.9",
+    "commander": "^12.1.0",
+    "js-yaml": "^4.1.0",
+    "protokol-sdk": "file:../protokol-sdk",
+    "tar": "^7.4.3",
+    "ws": "^8.18.0",
+    "yaml": "^2.5.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.3.0",
+    "@types/ws": "^8.5.12",
+    "typescript": "^5.5.4"
+  },
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "pkit": "dist/bin/toolkit"
+  }
+}