@wocker/ws 1.0.3 → 1.0.4

package/lib/decorators/Inject.d.ts

@@ -0,0 +1 @@
+export declare const Inject: () => (target: any) => void;

package/lib/decorators/Inject.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Inject = void 0;
+const Inject = () => {
+    return (target) => {
+    };
+};
+exports.Inject = Inject;

package/lib/decorators/Injectable.d.ts

@@ -0,0 +1,4 @@
+import { DI } from "../makes";
+export declare const Injectable: () => <T extends new (...rest: any[]) => {}>(Target: T) => {
+    new (di: DI): {};
+} & T;

package/lib/decorators/Injectable.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Injectable = void 0;
+const Injectable = () => {
+    return (Target) => {
+        return class extends Target {
+            constructor(di) {
+                const types = Reflect.getMetadata("design:paramtypes", Target);
+                const params = types.map((type) => {
+                    return (di).resolveService(type);
+                });
+                super(...params);
+            }
+        };
+    };
+};
+exports.Injectable = Injectable;

package/lib/decorators/index.d.ts

@@ -0,0 +1 @@
+export * from "./Injectable";

package/lib/decorators/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Injectable"), exports);

package/lib/index.d.ts

@@ -1,5 +1,6 @@
 import { App } from "./App";
 declare const app: App;
 export { app };
+export * from "./decorators";
 export * from "./makes";
 export * from "./services";

package/lib/index.js

@@ -28,5 +28,6 @@ app.use(plugins_1.PageKitePlugin);
 app.use(plugins_1.PostgresPlugin);
 app.use(plugins_1.ProxmoxPlugin);
 app.use(plugins_1.RedisPlugin);
+__exportStar(require("./decorators"), exports);
 __exportStar(require("./makes"), exports);
 __exportStar(require("./services"), exports);

package/lib/makes/FS.d.ts

@@ -1,13 +1,13 @@
 /// <reference types="node" />
 /// <reference types="node" />
-/// <reference types="node" />
+import { FS as CoreFS } from "@wocker/core";
 import * as fs from "fs";
-import { Stats, BigIntStats, PathLike, PathOrFileDescriptor, WriteFileOptions, MakeDirectoryOptions, RmOptions } from "fs";
+import { Stats, BigIntStats, PathLike, PathOrFileDescriptor, WriteFileOptions, MakeDirectoryOptions } from "fs";
 import { PassThrough } from "readable-stream";
 type ReaddirFilesOptions = {
     recursive?: boolean;
 };
-declare class FS {
+declare class FS extends CoreFS {
     static access(path: PathLike): Promise<any>;
     static exists(path: PathLike): Promise<boolean>;
     static existsSync(path: PathLike): boolean;
@@ -17,21 +17,15 @@ declare class FS {
     static readdirFiles(path: string, options?: ReaddirFilesOptions): Promise<string[]>;
     static appendFile(path: PathOrFileDescriptor, data: any, options?: WriteFileOptions): Promise<unknown>;
     static appendFileSync(path: PathOrFileDescriptor, data: any, options?: WriteFileOptions): void;
-    static read(): void;
     static readBytes(filePath: PathLike, position?: number | bigint, size?: number | bigint): Promise<Buffer>;
-    static readFile(filePath: PathLike | number): Promise<Buffer>;
     static readFileSync(filePath: PathLike): Buffer;
-    static writeFile(filePath: PathOrFileDescriptor, data: string | NodeJS.ArrayBufferView, options?: WriteFileOptions): Promise<void>;
     static writeFileSync(path: PathLike, data: any, options?: WriteFileOptions): void;
     static createWriteStream(path: PathLike): fs.WriteStream;
-    static readJSON(...paths: string[]): Promise<any>;
-    static writeJSON(filePath: PathLike | number, data: any): Promise<void>;
     static unlink(filePath: PathLike): Promise<void>;
     static watch(filename: PathLike, options?: any): fs.FSWatcher;
     static stat(filename: PathLike, options?: Parameters<typeof fs.stat>[1]): Promise<Stats | BigIntStats>;
     static createReadStream(path: PathLike, options?: Parameters<typeof fs.createReadStream>[1]): fs.ReadStream;
     static createReadLinesStream(path: PathLike, count?: number): PassThrough;
     static copyFile(src: PathLike, dest: PathLike): Promise<void>;
-    static rm(path: PathLike, options?: RmOptions): Promise<unknown>;
 }
 export { FS };

package/lib/makes/FS.js

@@ -24,10 +24,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FS = void 0;
+const core_1 = require("@wocker/core");
 const fs = __importStar(require("fs"));
 const Path = __importStar(require("path"));
 const readable_stream_1 = require("readable-stream");
-class FS {
+class FS extends core_1.FS {
     static async access(path) {
         return new Promise((resolve, reject) => {
             fs.access(path, (err) => {
@@ -131,8 +132,6 @@ class FS {
     static appendFileSync(path, data, options) {
         return fs.appendFileSync(path, data, options);
     }
-    static read() {
-    }
     static async readBytes(filePath, position = 0, size) {
         if (position < 0 && typeof size === "undefined") {
             const stats = await FS.stat(filePath);
@@ -171,56 +170,15 @@ class FS {
             });
         });
     }
-    static async readFile(filePath) {
-        return new Promise((resolve, reject) => {
-            fs.readFile(filePath, (err, data) => {
-                if (!err) {
-                    resolve(data);
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
     static readFileSync(filePath) {
         return fs.readFileSync(filePath);
     }
-    static async writeFile(filePath, data, options) {
-        return new Promise((resolve, reject) => {
-            fs.writeFile(filePath, data, options, (err) => {
-                if (!err) {
-                    resolve();
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
     static writeFileSync(path, data, options) {
         return fs.writeFileSync(path, data, options);
     }
     static createWriteStream(path) {
         return fs.createWriteStream(path);
     }
-    static async readJSON(...paths) {
-        const res = await new Promise((resolve, reject) => {
-            const filePath = Path.join(...paths);
-            fs.readFile(filePath, (err, data) => {
-                if (err) {
-                    reject(err);
-                    return;
-                }
-                resolve(data);
-            });
-        });
-        return JSON.parse(res.toString());
-    }
-    static async writeJSON(filePath, data) {
-        const json = JSON.stringify(data, null, 4);
-        return FS.writeFile(filePath, json);
-    }
     static async unlink(filePath) {
         return new Promise((resolve, reject) => {
             fs.unlink(filePath, (err) => {
@@ -330,15 +288,5 @@ class FS {
             });
         });
     }
-    static async rm(path, options) {
-        return new Promise((resolve, reject) => {
-            fs.rm(path, options, (err) => {
-                if (err) {
-                    return reject(err);
-                }
-                return resolve(undefined);
-            });
-        });
-    }
 }
 exports.FS = FS;

package/lib/utils/exec.js

@@ -4,11 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.exec = void 0;
-const core_1 = require("@wocker/core");
 const child_process_1 = require("child_process");
 const chalk_1 = __importDefault(require("chalk"));
+const makes_1 = require("../makes");
 const exec = async (command) => {
-    core_1.Logger.info(` > ${command.trim().replace(/\s+/g, " ")}`);
+    makes_1.Logger.info(` > ${command.trim().replace(/\s+/g, " ")}`);
     return new Promise((resolve, reject) => {
         const worker = (0, child_process_1.exec)(command, {
             maxBuffer: Infinity
@@ -32,10 +32,10 @@ const exec = async (command) => {
             });
         }
         worker.on("close", (code) => {
-            core_1.Logger.info("close", chalk_1.default.red(code));
+            makes_1.Logger.info("close", chalk_1.default.red(code));
         });
         worker.on("exit", (code) => {
-            core_1.Logger.info("exit", chalk_1.default.red(code));
+            makes_1.Logger.info("exit", chalk_1.default.red(code));
         });
     });
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wocker/ws",
-    "version": "1.0.3",
+    "version": "1.0.4",
     "author": "Kris Papercut <krispcut@gmail.com>",
     "description": "Docker workspace for web projects",
     "license": "MIT",