@prestizni-software/server-dem 0.2.21 → 0.2.22

package/AutoUpdateManagerClass.ts

@@ -1,5 +1,5 @@
-import { AutoUpdated } from "./AutoUpdatedClientObjectClass.ts";
-import { Constructor, IsData, LoggersType, SocketType } from "./CommonTypes.ts";
+import { AutoUpdated } from "./AutoUpdatedClientObjectClass.js";
+import { Constructor, IsData, LoggersType, SocketType } from "./CommonTypes.js";
 import "reflect-metadata";
 
 export abstract class AutoUpdateManager<T extends Constructor<any>> {
@@ -7,7 +7,7 @@ export abstract class AutoUpdateManager<T extends Constructor<any>> {
   public socket: SocketType;
   protected classParam: T;
   protected properties: (keyof T)[];
-  protected classers: Record<string, AutoUpdateManager<any>>;
+  public readonly classers: Record<string, AutoUpdateManager<any>>;
   protected loggers: LoggersType = {
     info: () => {},
     debug: () => {},

package/AutoUpdateServerManagerClass.ts

@@ -1,55 +1,73 @@
 import { Server, Socket } from "socket.io";
-import { AutoUpdateManager } from "./AutoUpdateManagerClass.ts";
-import { createAutoUpdatedClass } from "./AutoUpdatedServerObjectClass.ts";
+import { AutoUpdateManager } from "./AutoUpdateManagerClass.js";
+import {
+  createAutoUpdatedClass,
+} from "./AutoUpdatedServerObjectClass.js";
 import {
   Constructor,
   IsData,
   LoggersType,
   Paths,
+  PathValueOf,
   ServerResponse,
   ServerUpdateRequest,
-} from "./CommonTypes.ts";
-import { BeAnObject, ReturnModelType } from "@typegoose/typegoose/lib/types.ts";
+} from "./CommonTypes.js";
+import { BeAnObject, ReturnModelType } from "@typegoose/typegoose/lib/types.js";
 import { getModelForClass } from "@typegoose/typegoose";
 export type WrappedInstances<T extends Record<string, Constructor<any>>> = {
   [K in keyof T]: AutoUpdateServerManager<T[K]>;
 };
 type AccessDefinitions<C extends Constructor<any>> = {
-  [K in Paths<C>]: {
+  [K in Paths<C>]?: {
     access?: string[];
     update?: boolean;
   };
 };
 
-export type AutoStatusDefinitions<C extends Constructor<any>> = {
+export type AutoStatusDefinitions<
+  C extends Constructor<any>,
+  E extends Record<string, string | number>,
+  S extends StatusDefinition<C>
+> = {
   statusProperty: Paths<C>;
-  statusEnum: Record<string, string | number>;
-  definitions: Record<string, {}>;
+  statusEnum: E;
+  definitions: { [K in keyof E]: S };
+};
+
+type StatusDefinition<C extends Constructor<any>> = {
+  [K in Paths<C>]?: PathValueOf<C, K>;
 };
 
 export function createAutoStatusDefinitions<
   C extends Constructor<any>,
-  E extends { [k: string]: string | number }
->(def: {
-  class: C;
-  statusProperty: Paths<C>;
-  statusEnum: E;
-  definitions: { [K in keyof E]: {} };
-}): AutoStatusDefinitions<C> & {
-  statusEnum: E;
-  definitions: { [K in keyof E]: {} };
-} {
-  return def;
+  E extends { [k: string]: string | number },
+  S extends StatusDefinition<C>
+>(
+  _class: C,
+  _template: S,
+  statusProperty: Paths<C>,
+  statusEnum: E,
+  definitions: { [K in keyof E]: S }
+): AutoStatusDefinitions<C, E, S> {
+  return {
+    statusProperty,
+    statusEnum,
+    definitions,
+  };
 }
 
-export type AUSOptions<T extends Record<string, Constructor<any>>> = {
+export type AUSDefinitions<T extends Record<string, Constructor<any>>> = {
   [K in keyof T]: ServerManagerDefinition<T[K]>;
 };
 
-export type AUSOption<C extends Constructor<any>> =  {
-    accessDefinitions?: Partial<AccessDefinitions<C>>;
-    autoStatusDefinitions?: Partial<AutoStatusDefinitions<C>>;
-  };
+export type AUSOption<C extends Constructor<any>> = {
+  accessDefinitions?: Partial<AccessDefinitions<C>>;
+  autoStatusDefinitions?: AutoStatusDefinitions<
+    C,
+    { [k: string]: string | number },
+    StatusDefinition<C>
+  >;
+};
 
 type ServerManagerDefinition<C extends Constructor<any>> = {
   class: C;
@@ -59,7 +77,7 @@ type ServerManagerDefinition<C extends Constructor<any>> = {
 export async function AUSManagerFactory<
   T extends Record<string, Constructor<any>>
 >(
-  defs: AUSOptions<T>,
+  defs: AUSDefinitions<T>,
   loggers: LoggersType,
   socket: Server,
   emitter: EventTarget
@@ -83,7 +101,6 @@ export async function AUSManagerFactory<
     await c.loadDB();
   }
 
-
   return classers as WrappedInstances<T>;
 }
 
@@ -92,7 +109,7 @@ export class AutoUpdateServerManager<
 > extends AutoUpdateManager<T> {
   public readonly model: ReturnModelType<T, BeAnObject>;
   private readonly clientSockets: Set<Socket> = new Set<Socket>();
-
+  public readonly options?: AUSOption<T>;
   constructor(
     classParam: T,
     loggers: LoggersType,
@@ -104,6 +121,7 @@ export class AutoUpdateServerManager<
   ) {
     super(classParam, socket, loggers, classers, emitter);
     this.model = model;
+    this.options = options;
   }
 
   public async loadDB() {
@@ -210,7 +228,7 @@ export class AutoUpdateServerManager<
       this.socket,
       document,
       this.loggers,
-      this.classers,
+      this,
       this.emitter
     );
   }
@@ -224,12 +242,12 @@ export class AutoUpdateServerManager<
       this.socket,
       entry,
       this.loggers,
-      this.classers,
+      this,
       this.emitter
     );
+    object.checkAutoStatusChange();
     this.classes[object._id] = object;
     this.classesAsArray.push(object);
-    this.socket.emit("new" + this.classParam.name, await object._id);
     return object;
   }
 }

package/AutoUpdatedClientObjectClass.ts

@@ -12,9 +12,10 @@ import {
   ServerResponse,
   ServerUpdateRequest,
   SocketType,
-} from "./CommonTypes.ts";
-import { AutoUpdateManager } from "./AutoUpdateManagerClass.ts";
+} from "./CommonTypes.js";
+import { AutoUpdateManager } from "./AutoUpdateManagerClass.js";
 import { ObjectId } from "bson";
+import { AutoUpdateClientManager } from "./AutoUpdateClientManagerClass.js";
 
 export type AutoUpdated<T extends Constructor<any>> =
   AutoUpdatedClientObject<T> & DeRef<InstanceOf<T>>;
@@ -23,7 +24,7 @@ export async function createAutoUpdatedClass<C extends Constructor<any>>(
   socket: SocketType,
   data: RefToId<IsData<InstanceType<C>>> | string,
   loggers: LoggersType,
-  autoClassers: { [key: string]: AutoUpdateManager<any> },
+  autoClassers: AutoUpdateClientManager<any>,
   emitter: EventTarget
 ): Promise<AutoUpdated<C>> {
   if (typeof data !== "string")
@@ -60,7 +61,7 @@ export abstract class AutoUpdatedClientObject<T extends Constructor<any>> {
   protected readonly emitter;
   protected readonly properties: (keyof T)[];
   protected readonly className: string;
-  protected autoClassers: Record<string, AutoUpdateManager<any>>;
+  protected autoClasser: AutoUpdateManager<any>;
   protected isLoadingReferences = false;
   public readonly classProp: Constructor<T>;
   private readonly EmitterID = new ObjectId().toHexString();
@@ -91,14 +92,14 @@ export abstract class AutoUpdatedClientObject<T extends Constructor<any>> {
     properties: (keyof T)[],
     className: string,
     classProperty: Constructor<T>,
-    autoClassers: Record<string, AutoUpdateManager<any>>,
+    autoClasser: AutoUpdateManager<any>,
     emitter: EventTarget
   ) {
     this.emitter = emitter;
     this.classProp = classProperty;
     this.isLoadingReferences = true;
     this.isLoading = true;
-    this.autoClassers = autoClassers;
+    this.autoClasser = autoClasser;
     this.className = className;
     this.properties = properties;
     this.loggers.debug = loggers.debug;
@@ -125,7 +126,7 @@ export abstract class AutoUpdatedClientObject<T extends Constructor<any>> {
             res.data as any,
             properties,
             classProperty as any,
-            autoClassers
+            autoClasser
           );
           this.data = res.data as IsData<T>;
           this.isLoading = false;
@@ -139,12 +140,12 @@ export abstract class AutoUpdatedClientObject<T extends Constructor<any>> {
         data as any,
         properties,
         classProperty as any,
-        autoClassers
+        autoClasser
       );
       this.data = data as any;
 
       if (this.data._id === "") this.handleNewObject(data as any);
-      else this.isLoading = false;
+      else {this.isLoading = false};
     }
     if (!this.isServer) this.openSockets();
     this.generateSettersAndGetters();
@@ -167,7 +168,7 @@ export abstract class AutoUpdatedClientObject<T extends Constructor<any>> {
         res.data as any,
         this.properties,
         this.classProp as any,
-        this.autoClassers
+        this.autoClasser
       );
       this.data = res.data as IsData<T>;
       this.isLoading = false;
@@ -272,7 +273,7 @@ export abstract class AutoUpdatedClientObject<T extends Constructor<any>> {
   }
 
   protected findReference(id: string): AutoUpdated<any> | undefined {
-    for (const classer of Object.values(this.autoClassers)) {
+    for (const classer of Object.values(this.autoClasser.classers)) {
       const result = classer.getObject(id);
       if (result) return result;
     }
@@ -321,6 +322,7 @@ export abstract class AutoUpdatedClientObject<T extends Constructor<any>> {
       const pathArr = lastPath.split(".");
       if (pathArr.length === 1) {
         (this.data as any)[key as any] = value;
+      await this.checkAutoStatusChange();
         return true;
       }
       const pathMinusLast = pathArr.splice(0, 1);
@@ -329,6 +331,7 @@ export abstract class AutoUpdatedClientObject<T extends Constructor<any>> {
         ref = ref[p];
       }
       ref[pathArr.at(-1)!] = value;
+      await this.checkAutoStatusChange();
       return true;
     } catch (error) {
       this.loggers.error(error);
@@ -336,6 +339,15 @@ export abstract class AutoUpdatedClientObject<T extends Constructor<any>> {
     }
   }
 
+  public getValue(key: Paths<T>) {
+    let value: any;
+    for (const part of key.split(".")) {
+      if (value) value = value[part];
+      else value = (this.data as any)[part];
+    }
+    return value;
+  }
+
   protected async setValueInternal(key: string, value: any): Promise<boolean> {
     const update: ServerUpdateRequest<T> = this.makeUpdate(key, value);
     const promise = new Promise<boolean>((resolve) => {
@@ -360,11 +372,15 @@ export abstract class AutoUpdatedClientObject<T extends Constructor<any>> {
     return { _id: id, key, value } as any;
   }
 
+  protected async checkAutoStatusChange() {
+    return;
+  }
+
   // return a properly typed AutoUpdatedClientClass (or null)
   // inside AutoUpdatedClientClass
   protected resolveReference(id: string): AutoUpdatedClientObject<any> | null {
-    if (!this.autoClassers) throw new Error("No autoClassers");
-    for (const autoClasser of Object.values(this.autoClassers)) {
+    if (!this.autoClasser) throw new Error("No autoClasser");
+    for (const autoClasser of Object.values(this.autoClasser.classers)) {
       const data = autoClasser.getObject(id);
       if (data) return data;
     }
@@ -395,10 +411,10 @@ export abstract class AutoUpdatedClientObject<T extends Constructor<any>> {
   }
 
   private async handleLoadOnForced(obj: any, key: string) {
-    if (!this.autoClassers) throw new Error("No autoClassers");
+    if (!this.autoClasser) throw new Error("No autoClassers");
     const refId = obj[key];
     if (refId) {
-      for (const classer of Object.values(this.autoClassers)) {
+      for (const classer of Object.values(this.autoClasser.classers)) {
         const result = classer.getObject(refId);
         if (result) {
           obj[key] = result;
@@ -482,7 +498,7 @@ function checkForMissingRefs<C extends Constructor<any>>(
   data: IsData<InstanceType<C>>,
   props: any,
   classParam: C,
-  autoClassers: { [key: string]: AutoUpdateManager<any> }
+  autoClassers: AutoUpdateManager<any>
 ) {
   if (typeof data !== "string") {
     const entryKeys = Object.keys(data);
@@ -491,7 +507,7 @@ function checkForMissingRefs<C extends Constructor<any>>(
         !entryKeys.includes(prop.toString()) &&
         getMetadataRecursive("isRef", classParam.prototype, prop.toString())
       ) {
-        findMissingObjectReference(data, prop, autoClassers);
+        findMissingObjectReference(data, prop, autoClassers.classers);
       }
     }
   }

package/AutoUpdatedServerObjectClass.ts

@@ -1,6 +1,6 @@
-import { IObjectWithTypegooseFunction } from "@typegoose/typegoose/lib/types.ts";
+import { IObjectWithTypegooseFunction } from "@typegoose/typegoose/lib/types.js";
 import { Types, Document } from "mongoose";
-import { AutoUpdatedClientObject } from "./AutoUpdatedClientObjectClass.ts";
+import { AutoUpdatedClientObject } from "./AutoUpdatedClientObjectClass.js";
 import {
   AutoProps,
   Constructor,
@@ -10,9 +10,8 @@ import {
   ServerUpdateRequest,
   SocketType,
   UnboxConstructor,
-} from "./CommonTypes.ts";
-import { AutoUpdateManager } from "./AutoUpdateManagerClass.ts";
-import { AutoUpdateServerManager } from "./AutoUpdateServerManagerClass.ts";
+} from "./CommonTypes.js";
+import { AutoUpdateServerManager } from "./AutoUpdateServerManagerClass.js";
 import "reflect-metadata";
 
 export type AutoUpdated<T extends Constructor<any>> = AutoUpdatedServerObject<T> & UnboxConstructor<T>;
@@ -22,7 +21,7 @@ export async function createAutoUpdatedClass<C extends Constructor<any>>(
   socket: SocketType,
   data: DocWithProps<InstanceType<C>>,
   loggers: LoggersType,
-  autoClassers: Record<string, AutoUpdateManager<any>>,
+  autoClasser: AutoUpdateServerManager<any>,
   emitter: EventTarget
 ): Promise<AutoProps<C> & AutoUpdated<InstanceType<C>> & DeRef<InstanceType<C>>> {
   const instance = new (class extends AutoUpdatedServerObject<
@@ -37,10 +36,11 @@ export async function createAutoUpdatedClass<C extends Constructor<any>>(
     ) as (keyof InstanceType<C>)[],
     classParam.name,
     classParam,
-    autoClassers,
+    autoClasser,
     emitter
   );
   await instance.isLoadedAsync();
+  await instance.checkAutoStatusChange();
   return instance as AutoProps<C> & AutoUpdated<InstanceType<C>> & DeRef<InstanceType<C>>;
 }
 
@@ -50,6 +50,7 @@ export abstract class AutoUpdatedServerObject<
 > extends AutoUpdatedClientObject<T> {
   protected readonly isServer: boolean = true;
   private readonly entry: DocWithProps<T>;
+  protected override autoClasser: AutoUpdateServerManager<any>;
 
   constructor(
     socket: SocketType,
@@ -63,7 +64,7 @@ export abstract class AutoUpdatedServerObject<
     properties: (keyof T)[],
     className: string,
     classProp: Constructor<T>,
-    autoClassers: Record<string, AutoUpdateManager<any>>,
+    autoClasser: AutoUpdateServerManager<any>,
     emitter: EventTarget
   ) {
     super(
@@ -73,11 +74,11 @@ export abstract class AutoUpdatedServerObject<
       properties,
       className,
       classProp,
-      autoClassers,
+      autoClasser,
       emitter
     );
+    this.autoClasser = autoClasser;
     this.entry = data;
-    this.socket.emit("new", { id: this.data._id, type: className });
   }
 
   protected handleNewObject(_data: IsData<T>) {
@@ -86,7 +87,7 @@ export abstract class AutoUpdatedServerObject<
   protected async setValueInternal(key: string, value: any): Promise<boolean> {
     try {
       await (
-        this.autoClassers[this.className] as AutoUpdateServerManager<any>
+        this.autoClasser.classers[this.className] as AutoUpdateServerManager<any>
       ).model.updateOne({ _id: this.data._id }, { $set: { [key]: value } });
 
       const update: ServerUpdateRequest<T> = this.makeUpdate(key, value);
@@ -104,6 +105,36 @@ export abstract class AutoUpdatedServerObject<
     await this.entry.deleteOne({ _id: this.data._id });
     this.wipeSelf();
   }
+
+  public override async checkAutoStatusChange() {
+      if (!this.autoClasser.options?.autoStatusDefinitions) return;
+      const statusPath = this.autoClasser.options.autoStatusDefinitions.statusProperty;
+      let finalStatus:
+        | keyof typeof this.autoClasser.options.autoStatusDefinitions.statusEnum
+        | null = "null";
+      for (const [currentStatus, statusDef] of Object.entries(
+        this.autoClasser.options.autoStatusDefinitions.definitions
+      )) {
+        finalStatus = currentStatus;
+        for (const [key, value] of Object.entries(statusDef)) {
+          if (this.getValue(key as any) !== value) {
+            finalStatus = null;
+            break;
+          }
+        }
+  
+        if (!finalStatus) continue;
+        if(this.autoClasser.options.autoStatusDefinitions.statusEnum[finalStatus] === this.getValue(statusPath as any)) break;
+        await this.setValue(
+          statusPath as any,
+          this.autoClasser.options.autoStatusDefinitions.statusEnum[finalStatus] as any
+        );
+        break;
+      }
+      if (!finalStatus) 
+        throw new Error(`No final status found`);
+    }
+  
 }
 
 export type DocWithProps<T> = Document &

package/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [0.2.22](https://github.com/Prestizni-Software/server-dem/compare/v0.2.21...v0.2.22) (2025-11-10)
+
 ### [0.2.21](https://github.com/Prestizni-Software/server-dem/compare/v0.2.20...v0.2.21) (2025-11-10)
 
 ### [0.2.20](https://github.com/Prestizni-Software/server-dem/compare/v0.2.19...v0.2.20) (2025-11-10)

package/CommonTypes.ts

@@ -1,7 +1,7 @@
 import { DefaultEventsMap, Server } from "socket.io";
 import { Socket as SocketClient } from "socket.io-client";
 import { ObjectId } from "bson";
-import { AutoUpdated } from "./AutoUpdatedClientObjectClass.ts";
+import { AutoUpdated } from "./AutoUpdatedClientObjectClass.js";
 import "reflect-metadata";
 
 export type Ref<T> = string | (T extends Constructor<any> ? AutoUpdated<T> : (T & { _id: string }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prestizni-software/server-dem",
-  "version": "0.2.21",
+  "version": "0.2.22",
   "description": "An solution for when making http requests is not a good solution",
   "keywords": [
     "websockets"

package/server.ts

@@ -1,8 +1,8 @@
-import * as AutoUpdateServerManagerClass from "./AutoUpdateServerManagerClass.ts";
-import * as AutoUpdateManagerClass from "./AutoUpdateManagerClass.ts";
-import * as AutoUpdatedClientObjectClass from "./AutoUpdatedClientObjectClass.ts";
-import * as AutoUpdatedServerObjectClass from "./AutoUpdatedServerObjectClass.ts";
-import * as CommonTypes from "./CommonTypes.ts";
+import * as AutoUpdateServerManagerClass from "./AutoUpdateServerManagerClass.js";
+import * as AutoUpdateManagerClass from "./AutoUpdateManagerClass.js";
+import * as AutoUpdatedClientObjectClass from "./AutoUpdatedClientObjectClass.js";
+import * as AutoUpdatedServerObjectClass from "./AutoUpdatedServerObjectClass.js";
+import * as CommonTypes from "./CommonTypes.js";
 
 module.exports = {
   AutoUpdateServerManagerClass,

package/tsconfig.json

@@ -4,7 +4,7 @@
 
     /* Projects */
     // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
-    "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    "composite": true,                                   /* Enable constraints that allow a TypeScript project to be used with project references. */
     // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
     // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
     // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
@@ -15,8 +15,8 @@
     // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
     // "jsx": "preserve",                                /* Specify what JSX code is generated. */
     // "libReplacement": true,                           /* Enable lib replacement. */
-    "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
-    "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    "experimentalDecorators": true,                      /* Enable experimental support for legacy experimental decorators. */
+    "emitDecoratorMetadata": true,                       /* Emit design-type metadata for decorated declarations in source files. */
     // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
     // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
     // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
@@ -26,9 +26,9 @@
     // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
 
     /* Modules */
-    "module": "node18",                                /* Specify what module code is generated. */
-    "rootDir": "./",                                /* Specify the root folder within your source files. */
-    "moduleResolution": "node16",                       /* Specify how TypeScript looks up a file from a given module specifier. */
+    "module": "es2022",                                  /* Specify what module code is generated. */
+    "rootDir": "./",                                     /* Specify the root folder within your source files. */
+    "moduleResolution": "bundler",                       /* Specify how TypeScript looks up a file from a given module specifier. */
     // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
     // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
     // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
@@ -36,13 +36,13 @@
     // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
     // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
     // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
-       "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    "allowImportingTsExtensions": false,                 /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
     // "rewriteRelativeImportExtensions": true,          /* Rewrite '.ts', '.tsx', '.mts', and '.cts' file extensions in relative import paths to their JavaScript equivalent in output files. */
     // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
     // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
     // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
     // "noUncheckedSideEffectImports": true,             /* Check side effect imports. */
-    "resolveJsonModule": true,                        /* Enable importing .json files. */
+    "resolveJsonModule": true,                           /* Enable importing .json files. */
     // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
     // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
 
@@ -54,12 +54,12 @@
     /* Emit */
     // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
     // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
-   "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
-    "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    "emitDeclarationOnly": false,                        /* Only output d.ts files and not JavaScript files. */
+    "sourceMap": true,                                   /* Create source map files for emitted JavaScript files. */
     // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
     // "noEmit": true,                                   /* Disable emitting files from a compilation. */
     // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
-    "outDir": "./dist",                                   /* Specify an output folder for all emitted files. */
+    "outDir": "./dist",                                  /* Specify an output folder for all emitted files. */
     // "removeComments": true,                           /* Disable emitting comments. */
     // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
     // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */