@wocker/core 1.0.23 → 1.0.24-beta.1

package/lib/core/Container.d.ts

@@ -1,13 +1,14 @@
 import { InstanceWrapper } from "./InstanceWrapper";
-import { Module } from "./Module";
-import { InjectionToken } from "../types/InjectionToken";
+import { ModuleWrapper } from "./ModuleWrapper";
+import { InjectionToken, ProviderType } from "../types";
 import { Type } from "../types/Type";
 export declare class Container {
-    readonly modules: Map<Type, Module>;
-    readonly providers: Map<InjectionToken, InstanceWrapper>;
+    readonly modules: Map<Type, ModuleWrapper>;
+    readonly globalProviders: Map<InjectionToken, InstanceWrapper>;
     constructor();
-    addModule<TInput = any>(type: Type<TInput>, module: Module): void;
+    addModule<TInput = any>(type: Type<TInput>, module: ModuleWrapper): void;
     hasModule<TInput = any>(type: Type<TInput>): boolean;
-    getModule<TInput = any>(type: Type<TInput>): Module<TInput>;
-    addProvider(type: Type, wrapper: InstanceWrapper): void;
+    getModule<TInput = any>(type: Type<TInput>): ModuleWrapper<TInput>;
+    addProvider(type: InjectionToken, wrapper: InstanceWrapper): void;
+    replace(type: InjectionToken, provider: ProviderType): void;
 }

package/lib/core/Container.js

@@ -3,14 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Container = void 0;
 const cli_1 = require("@kearisp/cli");
 const InstanceWrapper_1 = require("./InstanceWrapper");
-const Module_1 = require("./Module");
+const ModuleWrapper_1 = require("./ModuleWrapper");
 const env_1 = require("../env");
 class Container {
     constructor() {
         this.modules = new Map();
-        this.providers = new Map();
-        const cliWrapper = new InstanceWrapper_1.InstanceWrapper(new Module_1.Module(this, null), cli_1.Cli);
-        this.providers.set(cli_1.Cli, cliWrapper);
+        this.globalProviders = new Map();
+        const cliWrapper = new InstanceWrapper_1.InstanceWrapper(new ModuleWrapper_1.ModuleWrapper(this, null), cli_1.Cli);
+        this.globalProviders.set(cli_1.Cli, cliWrapper);
     }
     addModule(type, module) {
         this.modules.set(type, module);
@@ -29,7 +29,19 @@ class Container {
         const token = typeof type !== "string"
             ? Reflect.getMetadata(env_1.INJECT_TOKEN_METADATA, type) || type
             : type;
-        this.providers.set(token, wrapper);
+        this.globalProviders.set(token, wrapper);
+    }
+    replace(type, provider) {
+        const token = typeof type !== "string"
+            ? Reflect.getMetadata(env_1.INJECT_TOKEN_METADATA, type) || type
+            : type;
+        const wrapper = this.globalProviders.get(token);
+        if (wrapper) {
+            wrapper.replace(provider);
+        }
+        this.modules.forEach((moduleRef) => {
+            moduleRef.replace(token, provider);
+        });
     }
 }
 exports.Container = Container;

package/lib/core/ControllerWrapper.d.ts

@@ -1,15 +1,15 @@
 import "reflect-metadata";
 import { CommandInput } from "@kearisp/cli";
 import { InstanceWrapper } from "./InstanceWrapper";
-import { Module } from "./Module";
+import { ModuleWrapper } from "./ModuleWrapper";
 import { Type } from "../types/Type";
 import { Route } from "./Route";
 export declare class ControllerWrapper<TInput = any> extends InstanceWrapper {
-    readonly type: Type<TInput>;
+    readonly _type: Type<TInput>;
     description?: string;
     commands: Route[];
     completions: Route[];
-    constructor(module: Module, type: Type<TInput>);
+    constructor(module: ModuleWrapper, type: Type<TInput>);
     getCompletionCommands(name: string, command: string): Route[];
     run(route: Route, input: CommandInput): any;
 }

package/lib/core/ControllerWrapper.js

@@ -10,12 +10,12 @@ class ControllerWrapper extends InstanceWrapper_1.InstanceWrapper {
         super(module, type);
         this.commands = [];
         this.completions = [];
-        if (!this.type) {
+        if (!this._type) {
             return;
         }
-        this.description = Reflect.getMetadata(env_1.DESCRIPTION_METADATA, this.type) || "";
-        for (const method of Object.getOwnPropertyNames(this.type.prototype)) {
-            const route = new Route_1.Route(this.type, method);
+        this.description = Reflect.getMetadata(env_1.DESCRIPTION_METADATA, this._type) || "";
+        for (const method of Object.getOwnPropertyNames(this._type.prototype)) {
+            const route = new Route_1.Route(this._type, method);
             if (route.isCommand) {
                 this.commands.push(route);
             }

package/lib/core/InstanceWrapper.d.ts

@@ -1,13 +1,16 @@
-import { Module } from "./Module";
-import { Provider } from "../types/Provider";
+import { ModuleWrapper } from "./ModuleWrapper";
+import { ProviderType, InjectionToken } from "../types";
 import { Type } from "../types/Type";
-import { InjectionToken } from "../types/InjectionToken";
 export declare class InstanceWrapper<TInput = any> {
-    protected readonly module: Module;
-    protected readonly provider: Provider<TInput>;
-    protected _instance?: TInput | undefined;
-    readonly token: InjectionToken<TInput>;
-    readonly type?: Type<TInput>;
-    constructor(module: Module, provider: Provider<TInput>, _instance?: TInput | undefined);
+    protected readonly module: ModuleWrapper;
+    protected readonly provider: ProviderType<TInput>;
+    protected _token: InjectionToken<TInput>;
+    protected _type?: Type<TInput>;
+    protected _instance?: TInput;
+    constructor(module: ModuleWrapper, provider: ProviderType<TInput>);
+    protected normalizeProvider(provider: ProviderType): any[];
+    get type(): Type<TInput> | undefined;
+    get token(): InjectionToken<TInput>;
     get instance(): TInput;
+    replace(provider: ProviderType<TInput>): void;
 }

package/lib/core/InstanceWrapper.js

@@ -3,30 +3,42 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InstanceWrapper = void 0;
 const env_1 = require("../env");
 class InstanceWrapper {
-    constructor(module, provider, _instance) {
+    constructor(module, provider) {
         this.module = module;
         this.provider = provider;
-        this._instance = _instance;
-        if ("provide" in this.provider && "useValue" in this.provider) {
-            this.token = this.provider.provide;
-            this._instance = this.provider.useValue;
-            return;
-        }
-        if ("provide" in this.provider && "useClass" in this.provider) {
-            this.token = this.provider.provide;
-            this.type = this.provider.useClass;
-            return;
+        const [token, type, instance] = this.normalizeProvider(provider);
+        this._token = token;
+        this._type = type;
+        this._instance = instance;
+    }
+    normalizeProvider(provider) {
+        if (provider && typeof provider === "object") {
+            if ("provide" in provider && "useValue" in provider) {
+                return [provider.provide, null, provider.useValue];
+            }
+            if ("provide" in provider && "useClass" in provider) {
+                return [provider.provide, provider.useClass, null];
+            }
         }
-        this.token = Reflect.getMetadata(env_1.INJECT_TOKEN_METADATA, this.provider) || this.provider;
-        this.type = this.provider;
+        return [
+            Reflect.getMetadata(env_1.INJECT_TOKEN_METADATA, provider) || provider,
+            provider,
+            null
+        ];
+    }
+    get type() {
+        return this._type;
+    }
+    get token() {
+        return this._token;
     }
     get instance() {
         if (!this._instance) {
-            if (!this.type) {
+            if (!this._type) {
                 throw new Error("Type not defined");
             }
-            const types = Reflect.getMetadata(env_1.PARAMTYPES_METADATA, this.type) || [];
-            const selfTypes = Reflect.getMetadata(env_1.SELF_DECLARED_DEPS_METADATA, this.type) || [];
+            const types = Reflect.getMetadata(env_1.PARAMTYPES_METADATA, this._type) || [];
+            const selfTypes = Reflect.getMetadata(env_1.SELF_DECLARED_DEPS_METADATA, this._type) || [];
             if (selfTypes.length > 0) {
                 selfTypes.forEach(({ index, token }) => {
                     types[index] = token;
@@ -35,9 +47,15 @@ class InstanceWrapper {
             const params = types.map((type) => {
                 return this.module.get(type);
             });
-            this._instance = new this.type(...params);
+            this._instance = new this._type(...params);
         }
         return this._instance;
     }
+    replace(provider) {
+        const [token, type, instance] = this.normalizeProvider(provider);
+        this._token = token;
+        this._type = type;
+        this._instance = instance;
+    }
 }
 exports.InstanceWrapper = InstanceWrapper;

package/lib/core/{Module.d.ts → ModuleWrapper.d.ts}

@@ -1,9 +1,9 @@
-import { Provider } from "../types/Provider";
+import { InjectionToken, ProviderType } from "../types";
 import { Type } from "../types/Type";
 import { Container } from "./Container";
 import { InstanceWrapper } from "./InstanceWrapper";
 import { ControllerWrapper } from "./ControllerWrapper";
-export declare class Module<TInput = any> {
+export declare class ModuleWrapper<TInput = any> {
     readonly container: Container;
     readonly type: TInput;
     imports: Map<any, InstanceWrapper>;
@@ -12,8 +12,9 @@ export declare class Module<TInput = any> {
     exports: Set<any>;
     constructor(container: Container, type: TInput);
     get<TInput = any, TResult = TInput>(type: Type<TInput> | Function | string | symbol): TResult;
-    getWrapper(type: any): InstanceWrapper | undefined;
-    addProvider(provider: Provider, instance?: any): void;
+    getWrapper(type: InjectionToken): InstanceWrapper | undefined;
+    addProvider(provider: ProviderType): void;
     addController(type: any): void;
     addExport(type: any): void;
+    replace(token: InjectionToken, provider: ProviderType): void;
 }

package/lib/core/{Module.js → ModuleWrapper.js}

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Module = void 0;
+exports.ModuleWrapper = void 0;
 const InstanceWrapper_1 = require("./InstanceWrapper");
 const ControllerWrapper_1 = require("./ControllerWrapper");
 const env_1 = require("../env");
-class Module {
+class ModuleWrapper {
     constructor(container, type) {
         this.container = container;
         this.type = type;
@@ -32,12 +32,12 @@ class Module {
             : type;
         const wrapper = this.providers.get(token);
         if (!wrapper) {
-            return this.container.providers.get(token);
+            return this.container.globalProviders.get(token);
         }
         return wrapper;
     }
-    addProvider(provider, instance) {
-        const wrapper = new InstanceWrapper_1.InstanceWrapper(this, provider, instance);
+    addProvider(provider) {
+        const wrapper = new InstanceWrapper_1.InstanceWrapper(this, provider);
         this.providers.set(wrapper.token, wrapper);
     }
     addController(type) {
@@ -50,5 +50,12 @@ class Module {
             : type;
         this.exports.add(token);
     }
+    replace(token, provider) {
+        const wrapper = this.getWrapper(token);
+        if (!wrapper) {
+            return;
+        }
+        wrapper.replace(provider);
+    }
 }
-exports.Module = Module;
+exports.ModuleWrapper = ModuleWrapper;

package/lib/core/Scanner.d.ts

@@ -2,16 +2,16 @@ import "reflect-metadata";
 import { Cli } from "@kearisp/cli";
 import { Container } from "./Container";
 import { ControllerWrapper } from "./ControllerWrapper";
-import { Module } from "./Module";
+import { ModuleWrapper } from "./ModuleWrapper";
 export declare class Scanner {
     readonly container: Container;
     constructor();
     scan(moduleType: any): Promise<void>;
-    protected scanModule(moduleType: any): Module;
-    protected scanControllers(module: Module): void;
-    protected scanProviders(module: Module): void;
-    protected scanImports(module: Module): void;
-    protected scanExports(module: Module): void;
+    protected scanModule(moduleType: any): ModuleWrapper;
+    protected scanControllers(module: ModuleWrapper): void;
+    protected scanProviders(module: ModuleWrapper): void;
+    protected scanImports(module: ModuleWrapper): void;
+    protected scanExports(module: ModuleWrapper): void;
     protected scanRoutes(): void;
     protected scanControllerRoutes(cli: Cli, wrapper: ControllerWrapper): void;
     protected scanDynamicModules(): Promise<void>;

package/lib/core/Scanner.js

@@ -13,7 +13,7 @@ exports.Scanner = void 0;
 require("reflect-metadata");
 const cli_1 = require("@kearisp/cli");
 const Container_1 = require("./Container");
-const Module_1 = require("./Module");
+const ModuleWrapper_1 = require("./ModuleWrapper");
 const env_1 = require("../env");
 class Scanner {
     constructor() {
@@ -31,7 +31,7 @@ class Scanner {
             ? this.container.getModule(moduleType)
             : null;
         if (!module) {
-            module = new Module_1.Module(this.container, moduleType);
+            module = new ModuleWrapper_1.ModuleWrapper(this.container, moduleType);
             this.container.addModule(moduleType, module);
             this.scanImports(module);
             this.scanControllers(module);
@@ -79,7 +79,7 @@ class Scanner {
         });
     }
     scanRoutes() {
-        const cliWrapper = this.container.providers.get(cli_1.Cli);
+        const cliWrapper = this.container.globalProviders.get(cli_1.Cli);
         if (!cliWrapper) {
             return;
         }

package/lib/decorators/Module.d.ts

@@ -1,8 +1,8 @@
 import { MODULE_METADATA } from "../env";
-import { Provider } from "../types/Provider";
+import { ProviderType } from "../types/ProviderType";
 export type ModuleMetadata = {
     [MODULE_METADATA.CONTROLLERS]?: any[];
-    [MODULE_METADATA.PROVIDERS]?: Provider[];
+    [MODULE_METADATA.PROVIDERS]?: ProviderType[];
     [MODULE_METADATA.IMPORTS]?: any[];
     [MODULE_METADATA.EXPORTS]?: any[];
 };

package/lib/env.d.ts

@@ -19,3 +19,5 @@ export declare enum MODULE_METADATA {
     PROVIDERS = "providers"
 }
 export declare const DATA_DIR: string;
+export declare const WOCKER_VERSION_KEY = "__WOCKER_VERSION__";
+export declare const WOCKER_DATA_DIR_KEY = "__WOCKER_DATA_DIR__";

package/lib/env.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DATA_DIR = exports.MODULE_METADATA = exports.PLUGIN_NAME_METADATA = exports.PLUGIN_DIR_KEY = exports.INJECT_TOKEN_METADATA = exports.SELF_DECLARED_DEPS_METADATA = exports.PARAMTYPES_METADATA = exports.OPTION_META = exports.ALIAS_METADATA = exports.ARGS_METADATA = exports.COMPLETION_METADATA = exports.COMMAND_METADATA = exports.DESCRIPTION_METADATA = exports.INJECTABLE_WATERMARK = exports.IS_MODULE_METADATA = exports.IS_GLOBAL_METADATA = void 0;
+exports.WOCKER_DATA_DIR_KEY = exports.WOCKER_VERSION_KEY = exports.DATA_DIR = exports.MODULE_METADATA = exports.PLUGIN_NAME_METADATA = exports.PLUGIN_DIR_KEY = exports.INJECT_TOKEN_METADATA = exports.SELF_DECLARED_DEPS_METADATA = exports.PARAMTYPES_METADATA = exports.OPTION_META = exports.ALIAS_METADATA = exports.ARGS_METADATA = exports.COMPLETION_METADATA = exports.COMMAND_METADATA = exports.DESCRIPTION_METADATA = exports.INJECTABLE_WATERMARK = exports.IS_MODULE_METADATA = exports.IS_GLOBAL_METADATA = void 0;
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 exports.IS_GLOBAL_METADATA = "IS_GLOBAL";
@@ -28,3 +28,5 @@ var MODULE_METADATA;
     MODULE_METADATA["PROVIDERS"] = "providers";
 })(MODULE_METADATA || (exports.MODULE_METADATA = MODULE_METADATA = {}));
 exports.DATA_DIR = process.env.WS_DIR || path_1.default.join(os_1.default.homedir(), ".workspace");
+exports.WOCKER_VERSION_KEY = "__WOCKER_VERSION__";
+exports.WOCKER_DATA_DIR_KEY = "__WOCKER_DATA_DIR__";

package/lib/index.d.ts

@@ -5,5 +5,12 @@ export * from "./decorators";
 export * from "./exceptions";
 export * from "./makes";
 export * from "./services";
+export { 
+/**
+ * @deprecated since v1.0.24. Use EventService instead.
+ * This export is maintained for backward compatibility.
+ * The AppEventsService class has been renamed to EventService.
+ */
+EventService as AppEventsService } from "./services";
 export * from "./types";
-export { IS_MODULE_METADATA, MODULE_METADATA, PLUGIN_NAME_METADATA, PLUGIN_DIR_KEY } from "./env";
+export { IS_MODULE_METADATA, MODULE_METADATA, PLUGIN_NAME_METADATA, PLUGIN_DIR_KEY, WOCKER_VERSION_KEY, WOCKER_DATA_DIR_KEY } from "./env";

package/lib/index.js

@@ -14,7 +14,7 @@ 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 });
-exports.PLUGIN_DIR_KEY = exports.PLUGIN_NAME_METADATA = exports.MODULE_METADATA = exports.IS_MODULE_METADATA = exports.CommandNotFoundError = exports.Cli = void 0;
+exports.WOCKER_DATA_DIR_KEY = exports.WOCKER_VERSION_KEY = exports.PLUGIN_DIR_KEY = exports.PLUGIN_NAME_METADATA = exports.MODULE_METADATA = exports.IS_MODULE_METADATA = exports.AppEventsService = exports.CommandNotFoundError = exports.Cli = void 0;
 require("reflect-metadata");
 var cli_1 = require("@kearisp/cli");
 Object.defineProperty(exports, "Cli", { enumerable: true, get: function () { return cli_1.Cli; } });
@@ -24,9 +24,18 @@ __exportStar(require("./decorators"), exports);
 __exportStar(require("./exceptions"), exports);
 __exportStar(require("./makes"), exports);
 __exportStar(require("./services"), exports);
+var services_1 = require("./services");
+/**
+ * @deprecated since v1.0.24. Use EventService instead.
+ * This export is maintained for backward compatibility.
+ * The AppEventsService class has been renamed to EventService.
+ */
+Object.defineProperty(exports, "AppEventsService", { enumerable: true, get: function () { return services_1.EventService; } });
 __exportStar(require("./types"), exports);
 var env_1 = require("./env");
 Object.defineProperty(exports, "IS_MODULE_METADATA", { enumerable: true, get: function () { return env_1.IS_MODULE_METADATA; } });
 Object.defineProperty(exports, "MODULE_METADATA", { enumerable: true, get: function () { return env_1.MODULE_METADATA; } });
 Object.defineProperty(exports, "PLUGIN_NAME_METADATA", { enumerable: true, get: function () { return env_1.PLUGIN_NAME_METADATA; } });
 Object.defineProperty(exports, "PLUGIN_DIR_KEY", { enumerable: true, get: function () { return env_1.PLUGIN_DIR_KEY; } });
+Object.defineProperty(exports, "WOCKER_VERSION_KEY", { enumerable: true, get: function () { return env_1.WOCKER_VERSION_KEY; } });
+Object.defineProperty(exports, "WOCKER_DATA_DIR_KEY", { enumerable: true, get: function () { return env_1.WOCKER_DATA_DIR_KEY; } });

package/lib/services/AppConfigService.d.ts

@@ -1,12 +1,41 @@
 import { AppConfig, PresetSource } from "../makes";
-export declare abstract class AppConfigService {
+import { ProjectRef } from "../types/ProjectRef";
+import { PluginRef } from "../types/PluginRef";
+import { AppFileSystemService } from "./AppFileSystemService";
+import { ProcessService } from "./ProcessService";
+type TypeMap = {
+    [type: string]: string;
+};
+export declare class AppConfigService {
+    readonly version: string;
+    protected readonly processService: ProcessService;
+    readonly fs: AppFileSystemService;
+    protected _pwd: string;
+    protected _config?: AppConfig;
+    protected readonly mapTypes: TypeMap;
+    constructor(version: string, processService: ProcessService, fs: AppFileSystemService);
     get experimentalFeatures(): string[];
-    abstract get config(): AppConfig;
-    get version(): string;
+    get debug(): boolean;
+    set debug(debug: boolean);
+    get config(): AppConfig;
+    get projects(): ProjectRef[];
+    get plugins(): PluginRef[];
+    /**
+     * @deprecated
+     */
     isVersionGTE(version: string): boolean;
-    abstract pwd(...parts: string[]): string;
-    abstract setPWD(pwd: string): void;
-    abstract dataPath(...args: string[]): string;
+    /**
+     * @deprecated
+     */
+    pwd(...parts: string[]): string;
+    /**
+     * @deprecated
+     */
+    setPWD(pwd: string): void;
+    /**
+     * @deprecated
+     */
+    dataPath(...args: string[]): string;
     /**
      * @deprecated
      */
@@ -15,9 +44,13 @@ export declare abstract class AppConfigService {
     removeProject(id: string): void;
     registerPreset(name: string, source: PresetSource, path?: string): void;
     unregisterPreset(name: string): void;
+    addPlugin(name: string, env?: PluginRef["env"]): void;
+    removePlugin(name: string): void;
     getMeta(name: string, byDefault?: string): string | undefined;
     getMeta(name: string, byDefault: string): string;
     setMeta(name: string, value: string): void;
     unsetMeta(name: string): void;
-    abstract save(): void;
+    getProjectTypes(): TypeMap;
+    save(): void;
 }
+export {};

package/lib/services/AppConfigService.js

@@ -5,18 +5,97 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AppConfigService = void 0;
+const path_1 = __importDefault(require("path"));
 const decorators_1 = require("../decorators");
+const makes_1 = require("../makes");
+const AppFileSystemService_1 = require("./AppFileSystemService");
+const ProcessService_1 = require("./ProcessService");
+const env_1 = require("../env");
 let AppConfigService = class AppConfigService {
+    constructor(version, processService, fs) {
+        this.version = version;
+        this.processService = processService;
+        this.fs = fs;
+        this.mapTypes = {
+            [makes_1.PROJECT_TYPE_PRESET]: "Preset",
+            [makes_1.PROJECT_TYPE_IMAGE]: "Image",
+            [makes_1.PROJECT_TYPE_DOCKERFILE]: "Dockerfile"
+        };
+        this._pwd = (process.cwd() || process.env.PWD);
+    }
     get experimentalFeatures() {
         return [
             "projectComposeType"
         ];
     }
-    get version() {
-        return "0.0.0";
+    get debug() {
+        return this.config.debug || false;
+    }
+    set debug(debug) {
+        this.config.debug = debug;
     }
+    get config() {
+        if (!this._config) {
+            let data = {};
+            if (this.fs.exists("wocker.config.js")) {
+                try {
+                    const { config } = require(this.fs.path("wocker.config.js"));
+                    data = config;
+                }
+                catch (err) {
+                    // TODO: Log somehow
+                    // this.logService.error(err);
+                    if (this.fs.exists("wocker.config.json")) {
+                        let json = this.fs.readJSON("wocker.config.json");
+                        if (typeof json === "string") {
+                            json = JSON.parse(json);
+                        }
+                        data = json;
+                    }
+                }
+            }
+            else if (this.fs.exists("wocker.config.json")) {
+                data = this.fs.readJSON("wocker.config.json");
+            }
+            else if (this.fs.exists("wocker.json")) {
+                let json = this.fs.readJSON("wocker.json");
+                if (typeof json === "string") {
+                    json = JSON.parse(json);
+                }
+                data = json;
+            }
+            else if (this.fs.exists("data.json")) {
+                data = this.fs.readJSON("data.json");
+            }
+            else if (!this.fs.exists()) {
+                this.fs.mkdir("", {
+                    recursive: true
+                });
+            }
+            this._config = new makes_1.AppConfig(data);
+        }
+        return this._config;
+    }
+    get projects() {
+        return this.config.projects;
+    }
+    get plugins() {
+        return this.config.plugins;
+    }
+    /**
+     * @deprecated
+     */
     isVersionGTE(version) {
         const current = this.version.split(".").map(Number);
         const compare = version.split(".").map(Number);
@@ -30,6 +109,24 @@ let AppConfigService = class AppConfigService {
         }
         return true;
     }
+    /**
+     * @deprecated
+     */
+    pwd(...parts) {
+        return this.processService.pwd(path_1.default.join(...parts));
+    }
+    /**
+     * @deprecated
+     */
+    setPWD(pwd) {
+        this.processService.chdir(pwd);
+    }
+    /**
+     * @deprecated
+     */
+    dataPath(...args) {
+        return this.fs.path(...args);
+    }
     /**
      * @deprecated
      */
@@ -38,7 +135,6 @@ let AppConfigService = class AppConfigService {
     }
     addProject(id, name, path) {
         this.config.addProject(id, name, path);
-        this.save();
     }
     removeProject(id) {
         this.config.removeProject(id);
@@ -52,6 +148,12 @@ let AppConfigService = class AppConfigService {
         this.config.unregisterPreset(name);
         this.save();
     }
+    addPlugin(name, env) {
+        this.config.addPlugin(name);
+    }
+    removePlugin(name) {
+        this.config.removePlugin(name);
+    }
     getMeta(name, byDefault) {
         return this.config.getMeta(name, byDefault);
     }
@@ -61,8 +163,33 @@ let AppConfigService = class AppConfigService {
     unsetMeta(name) {
         this.config.unsetMeta(name);
     }
+    getProjectTypes() {
+        if (this.config.getMeta("experimental.projectComposeType")) {
+            return Object.assign(Object.assign({}, this.mapTypes), { [makes_1.PROJECT_TYPE_COMPOSE]: "Docker compose" });
+        }
+        return this.mapTypes;
+    }
+    save() {
+        const fs = this.fs;
+        if (!fs.exists()) {
+            fs.mkdir("", {
+                recursive: true
+            });
+        }
+        fs.writeFile("wocker.config.js", this.config.toJsString());
+        fs.writeFile("wocker.config.json", this.config.toString()); // Backup file
+        if (fs.exists("data.json")) {
+            fs.rm("data.json");
+        }
+        if (fs.exists("wocker.json")) {
+            fs.rm("wocker.json");
+        }
+    }
 };
 exports.AppConfigService = AppConfigService;
 exports.AppConfigService = AppConfigService = __decorate([
-    (0, decorators_1.Injectable)("APP_CONFIG")
+    (0, decorators_1.Injectable)("APP_CONFIG"),
+    __param(0, (0, decorators_1.Inject)(env_1.WOCKER_VERSION_KEY)),
+    __metadata("design:paramtypes", [String, ProcessService_1.ProcessService,
+        AppFileSystemService_1.AppFileSystemService])
 ], AppConfigService);

package/lib/services/AppFileSystemService.d.ts

@@ -0,0 +1,4 @@
+import { FileSystem } from "../makes";
+export declare class AppFileSystemService extends FileSystem {
+    constructor(dataDir: string);
+}

package/lib/services/AppFileSystemService.js

@@ -0,0 +1,29 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppFileSystemService = void 0;
+const decorators_1 = require("../decorators");
+const makes_1 = require("../makes");
+const env_1 = require("../env");
+let AppFileSystemService = class AppFileSystemService extends makes_1.FileSystem {
+    constructor(dataDir) {
+        super(dataDir);
+    }
+};
+exports.AppFileSystemService = AppFileSystemService;
+exports.AppFileSystemService = AppFileSystemService = __decorate([
+    (0, decorators_1.Injectable)(),
+    __param(0, (0, decorators_1.Inject)(env_1.WOCKER_DATA_DIR_KEY)),
+    __metadata("design:paramtypes", [String])
+], AppFileSystemService);

package/lib/services/AppService.d.ts

@@ -0,0 +1,20 @@
+import { AppConfigService } from "./AppConfigService";
+import { AppFileSystemService } from "./AppFileSystemService";
+import { ProjectRef } from "../types/ProjectRef";
+type TypeMap = {
+    [type: string]: string;
+};
+export declare class AppService {
+    readonly version: string;
+    protected readonly appConfigService: AppConfigService;
+    protected readonly fs: AppFileSystemService;
+    constructor(version: string, appConfigService: AppConfigService, fs: AppFileSystemService);
+    get projects(): ProjectRef[];
+    isVersionGTE(version: string): boolean;
+    get experimentalFeatures(): string[];
+    getProjectTypes(): TypeMap;
+    addProject(id: string, name: string, path: string): void;
+    getMeta(name: string, byDefault?: string): string | undefined;
+    getMeta(name: string, byDefault: string): string;
+}
+export {};

package/lib/services/AppService.js

@@ -0,0 +1,62 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppService = void 0;
+const decorators_1 = require("../decorators");
+const AppConfigService_1 = require("./AppConfigService");
+const AppFileSystemService_1 = require("./AppFileSystemService");
+const env_1 = require("../env");
+let AppService = class AppService {
+    constructor(version, appConfigService, fs) {
+        this.version = version;
+        this.appConfigService = appConfigService;
+        this.fs = fs;
+    }
+    get projects() {
+        return this.appConfigService.projects;
+    }
+    isVersionGTE(version) {
+        const current = this.version.split(".").map(Number);
+        const compare = version.split(".").map(Number);
+        for (let i = 0; i < 3; i++) {
+            if (current[i] > compare[i]) {
+                return true;
+            }
+            else if (current[i] < compare[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    get experimentalFeatures() {
+        return this.appConfigService.experimentalFeatures;
+    }
+    getProjectTypes() {
+        return this.appConfigService.getProjectTypes();
+    }
+    addProject(id, name, path) {
+        this.appConfigService.addProject(id, name, path);
+        this.appConfigService.save();
+    }
+    getMeta(name, byDefault) {
+        return this.appConfigService.getMeta(name, byDefault);
+    }
+};
+exports.AppService = AppService;
+exports.AppService = AppService = __decorate([
+    (0, decorators_1.Injectable)("APP_SERVICE"),
+    __param(0, (0, decorators_1.Inject)(env_1.WOCKER_VERSION_KEY)),
+    __metadata("design:paramtypes", [String, AppConfigService_1.AppConfigService,
+        AppFileSystemService_1.AppFileSystemService])
+], AppService);

package/lib/services/EventService.d.ts

@@ -0,0 +1,9 @@
+export type EventHandle = (...args: any[]) => Promise<void> | void;
+export declare class EventService {
+    protected handles: {
+        [event: string]: Set<EventHandle>;
+    };
+    on(event: string, handle: EventHandle): (() => void);
+    off(event: string, handle: EventHandle): void;
+    emit(event: string, ...args: any[]): Promise<void>;
+}

package/lib/services/EventService.js

@@ -0,0 +1,53 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventService = void 0;
+const decorators_1 = require("../decorators");
+let EventService = class EventService {
+    constructor() {
+        this.handles = {};
+    }
+    on(event, handle) {
+        if (!this.handles[event]) {
+            this.handles[event] = new Set();
+        }
+        this.handles[event].add(handle);
+        return () => {
+            this.off(event, handle);
+        };
+    }
+    off(event, handle) {
+        if (!this.handles[event]) {
+            return;
+        }
+        this.handles[event].delete(handle);
+    }
+    emit(event, ...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.handles[event]) {
+                return;
+            }
+            for (const handle of this.handles[event].values()) {
+                yield handle(...args);
+            }
+        });
+    }
+};
+exports.EventService = EventService;
+exports.EventService = EventService = __decorate([
+    (0, decorators_1.Injectable)("APP_EVENTS_SERVICE")
+], EventService);

package/lib/services/LogService.d.ts

@@ -1,7 +1,15 @@
-export declare abstract class LogService {
-    abstract debug(...data: any[]): void;
-    abstract log(...data: any[]): void;
-    abstract info(...data: any[]): void;
-    abstract warn(...data: any[]): void;
-    abstract error(...data: any[]): void;
+import { AppConfigService } from "./AppConfigService";
+import { AppFileSystemService } from "./AppFileSystemService";
+export declare class LogService {
+    protected readonly appConfigService: AppConfigService;
+    protected readonly fs: AppFileSystemService;
+    constructor(appConfigService: AppConfigService, fs: AppFileSystemService);
+    protected get logName(): string;
+    protected _log(type: string, ...data: any[]): void;
+    debug(...data: any[]): void;
+    log(...data: any[]): void;
+    info(...data: any[]): void;
+    warn(...data: any[]): void;
+    error(...data: any[]): void;
+    clear(): void;
 }

package/lib/services/LogService.js

@@ -5,12 +5,58 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LogService = void 0;
+const format_1 = require("date-fns/format");
 const decorators_1 = require("../decorators");
+const AppConfigService_1 = require("./AppConfigService");
+const AppFileSystemService_1 = require("./AppFileSystemService");
 let LogService = class LogService {
+    constructor(appConfigService, fs) {
+        this.appConfigService = appConfigService;
+        this.fs = fs;
+    }
+    get logName() {
+        return "ws.log";
+    }
+    _log(type, ...data) {
+        if (type === "debug" && !this.appConfigService.config.debug) {
+            return;
+        }
+        const time = (0, format_1.format)(new Date(), "yyyy-MM-dd HH:mm:ss");
+        const logData = data.map((item) => {
+            return typeof item !== "string" ? JSON.stringify(item) : item;
+        }).join(" ");
+        if (!this.fs.exists(this.logName)) {
+            this.fs.writeFile(this.logName, "");
+        }
+        this.fs.appendFile(this.logName, `[${time}] ${type}: ${logData}\n`);
+    }
+    debug(...data) {
+        this._log("debug", ...data);
+    }
+    log(...data) {
+        this._log("log", ...data);
+    }
+    info(...data) {
+        this._log("info", ...data);
+    }
+    warn(...data) {
+        this._log("warn", ...data);
+    }
+    error(...data) {
+        this._log("error", ...data);
+    }
+    clear() {
+        this.fs.writeFile(this.logName, "");
+    }
 };
 exports.LogService = LogService;
 exports.LogService = LogService = __decorate([
-    (0, decorators_1.Injectable)("LOG_SERVICE")
+    (0, decorators_1.Injectable)("LOG_SERVICE"),
+    __metadata("design:paramtypes", [AppConfigService_1.AppConfigService,
+        AppFileSystemService_1.AppFileSystemService])
 ], LogService);

package/lib/services/PluginConfigService.js

@@ -38,7 +38,9 @@ let PluginConfigService = class PluginConfigService {
             }
             this._fs = new makes_1.FileSystem(this.pluginDir);
             if (!this._fs.exists()) {
-                this._fs.mkdir();
+                this._fs.mkdir("", {
+                    recursive: true
+                });
             }
         }
         return this._fs;

package/lib/services/{PluginFileSystem.d.ts → PluginFileSystemService.d.ts}

@@ -1,4 +1,4 @@
 import { FileSystem } from "../makes";
-export declare class PluginFileSystem extends FileSystem {
+export declare class PluginFileSystemService extends FileSystem {
     constructor(pluginDir: string);
 }

package/lib/services/{PluginFileSystem.js → PluginFileSystemService.js}

@@ -12,18 +12,18 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PluginFileSystem = void 0;
+exports.PluginFileSystemService = void 0;
 const decorators_1 = require("../decorators");
 const env_1 = require("../env");
 const makes_1 = require("../makes");
-let PluginFileSystem = class PluginFileSystem extends makes_1.FileSystem {
+let PluginFileSystemService = class PluginFileSystemService extends makes_1.FileSystem {
     constructor(pluginDir) {
         super(pluginDir);
     }
 };
-exports.PluginFileSystem = PluginFileSystem;
-exports.PluginFileSystem = PluginFileSystem = __decorate([
+exports.PluginFileSystemService = PluginFileSystemService;
+exports.PluginFileSystemService = PluginFileSystemService = __decorate([
     (0, decorators_1.Injectable)(),
     __param(0, (0, decorators_1.Inject)(env_1.PLUGIN_DIR_KEY)),
     __metadata("design:paramtypes", [String])
-], PluginFileSystem);
+], PluginFileSystemService);

package/lib/services/PresetService.d.ts

@@ -1,12 +1,15 @@
 import { EnvConfig } from "../types";
+import { Preset } from "../makes/Preset";
 type SearchOptions = Partial<{
     name: string;
+    source: string;
+    path: string;
 }>;
 declare abstract class PresetService {
     abstract getImageName(preset: any, buildArgs?: EnvConfig): string;
     abstract save(preset: any): Promise<void>;
     abstract get(name: string): Promise<any | null>;
-    abstract search(options?: SearchOptions): Promise<any[]>;
-    searchOne(options?: SearchOptions): Promise<any | null | undefined>;
+    abstract search(options?: SearchOptions): Preset[];
+    abstract searchOne(options?: SearchOptions): Preset | null;
 }
 export { PresetService, SearchOptions as PresetServiceSearchOptions };

package/lib/services/PresetService.js

@@ -1,21 +1,6 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PresetService = void 0;
 class PresetService {
-    searchOne(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [preset] = yield this.search(options);
-            return preset || null;
-        });
-    }
 }
 exports.PresetService = PresetService;

package/lib/services/ProcessService.d.ts

@@ -0,0 +1,5 @@
+export declare class ProcessService {
+    pwd(path?: string): string;
+    cd(path: string): void;
+    chdir(path: string): void;
+}

package/lib/services/{AppEventsService.js → ProcessService.js}

@@ -5,12 +5,25 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AppEventsService = void 0;
+exports.ProcessService = void 0;
+const path_1 = __importDefault(require("path"));
 const decorators_1 = require("../decorators");
-let AppEventsService = class AppEventsService {
+let ProcessService = class ProcessService {
+    pwd(path = "") {
+        return path_1.default.join(process.cwd(), path);
+    }
+    cd(path) {
+        this.chdir(this.pwd(path));
+    }
+    chdir(path) {
+        process.chdir(path);
+    }
 };
-exports.AppEventsService = AppEventsService;
-exports.AppEventsService = AppEventsService = __decorate([
-    (0, decorators_1.Injectable)("APP_EVENTS_SERVICE")
-], AppEventsService);
+exports.ProcessService = ProcessService;
+exports.ProcessService = ProcessService = __decorate([
+    (0, decorators_1.Injectable)()
+], ProcessService);

package/lib/services/ProjectService.d.ts

@@ -1,16 +1,18 @@
 import { Project } from "../makes/Project";
 type SearchParams = Partial<{
-    id: string;
     name: string;
     path: string;
 }>;
 export declare abstract class ProjectService {
-    abstract cdProject(name: string): Promise<void>;
-    abstract get(name?: string): Promise<Project>;
+    abstract get(name?: string): Project;
+    abstract save(project: Project): void;
+    abstract search(params: SearchParams): Project[];
     abstract start(project: Project): Promise<void>;
     abstract stop(project: Project): Promise<void>;
-    abstract save(project: Project): Promise<void>;
-    abstract search(params: SearchParams): Promise<Project[]>;
-    searchOne(params?: SearchParams): Promise<Project | null>;
+    searchOne(params?: SearchParams): Project | null;
+    /**
+     * @deprecated
+     */
+    cdProject(name?: string): void;
 }
 export { SearchParams as ProjectServiceSearchParams };

package/lib/services/ProjectService.js

@@ -5,25 +5,18 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProjectService = void 0;
 const decorators_1 = require("../decorators");
 let ProjectService = class ProjectService {
-    searchOne() {
-        return __awaiter(this, arguments, void 0, function* (params = {}) {
-            const [project] = yield this.search(params);
-            return project || null;
-        });
+    searchOne(params = {}) {
+        const [project] = this.search(params);
+        return project || null;
     }
+    /**
+     * @deprecated
+     */
+    cdProject(name) { }
 };
 exports.ProjectService = ProjectService;
 exports.ProjectService = ProjectService = __decorate([

package/lib/services/index.d.ts

@@ -1,10 +1,14 @@
 export * from "./AppConfigService";
-export * from "./AppEventsService";
+export * from "./AppFileSystemService";
+export * from "./AppService";
 export * from "./DockerService";
+export * from "./EventService";
 export * from "./KeystoreService";
 export * from "./LogService";
 export * from "./ModemService";
 export * from "./PluginConfigService";
+export * from "./PluginFileSystemService";
 export * from "./PresetService";
+export * from "./ProcessService";
 export * from "./ProjectService";
 export * from "./ProxyService";

package/lib/services/index.js

@@ -15,12 +15,16 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./AppConfigService"), exports);
-__exportStar(require("./AppEventsService"), exports);
+__exportStar(require("./AppFileSystemService"), exports);
+__exportStar(require("./AppService"), exports);
 __exportStar(require("./DockerService"), exports);
+__exportStar(require("./EventService"), exports);
 __exportStar(require("./KeystoreService"), exports);
 __exportStar(require("./LogService"), exports);
 __exportStar(require("./ModemService"), exports);
 __exportStar(require("./PluginConfigService"), exports);
+__exportStar(require("./PluginFileSystemService"), exports);
 __exportStar(require("./PresetService"), exports);
+__exportStar(require("./ProcessService"), exports);
 __exportStar(require("./ProjectService"), exports);
 __exportStar(require("./ProxyService"), exports);

package/lib/types/{Provider.d.ts → ProviderType.d.ts}

@@ -8,5 +8,5 @@ type ValueProvider<T = any> = {
     provide: InjectionToken;
     useValue: T;
 };
-export type Provider<T = any> = Type<T> | ClassProvider<T> | ValueProvider<T>;
+export type ProviderType<T = any> = Type<T> | ClassProvider<T> | ValueProvider<T>;
 export {};

package/lib/types/index.d.ts

@@ -1,4 +1,6 @@
 export * from "./EnvConfig";
 export * from "./FileSystemDriver";
+export * from "./InjectionToken";
 export * from "./PickProperties";
 export * from "./Volume";
+export * from "./ProviderType";

package/lib/types/index.js

@@ -16,5 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./EnvConfig"), exports);
 __exportStar(require("./FileSystemDriver"), exports);
+__exportStar(require("./InjectionToken"), exports);
 __exportStar(require("./PickProperties"), exports);
 __exportStar(require("./Volume"), exports);
+__exportStar(require("./ProviderType"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wocker/core",
-    "version": "1.0.23",
+    "version": "1.0.24-beta.1",
     "author": "Kris Papercut <krispcut@gmail.com>",
     "description": "Core of the Wocker",
     "license": "MIT",
@@ -27,6 +27,7 @@
     },
     "dependencies": {
         "@kearisp/cli": "^2.0.8",
+        "date-fns": "^4.1.0",
         "fs": "^0.0.1-security",
         "os": "^0.1.2",
         "path": "^0.12.7",

package/lib/services/AppEventsService.d.ts

@@ -1,6 +0,0 @@
-export type AppEventHandle = (...args: any[]) => Promise<void> | void;
-export declare abstract class AppEventsService {
-    abstract on(event: string, handle: AppEventHandle): void;
-    abstract off(event: string, handle: AppEventHandle): void;
-    abstract emit(event: string, ...args: any[]): Promise<void>;
-}