yet-another-storage-package 1.0.0

package/README.md

@@ -0,0 +1,13 @@
+# YASP (Yet Another Storage Package)
+YASP is a package for storing data.
+```ts
+import YASP from "yet-another-storage-package"
+const myYASP = new YASP<number>()
+
+myYASP.addValue("a", 20)
+    .addValue("b", 25)
+    .addValue("c", 30)
+
+myYASP.getValue("a") // 20
+```
+Files made with tsc.

package/errors.json

@@ -0,0 +1,4 @@
+{
+    "ValueAppending": "Error adding value: Value already exists, use changeValue() instead.",
+    "ValueNotFound": "Error finding value: Value does not exist."
+}

package/index.d.ts

@@ -0,0 +1,16 @@
+declare type YASPConfig = Partial<{
+    throwIfNotFound: boolean;
+}>;
+export default class YASP<T> {
+    protected data: Record<string, T>;
+    protected config: YASPConfig;
+    constructor(init?: Record<string, T>);
+    get Data(): Record<string, T>;
+    setConfig(conf: YASPConfig): this;
+    addConfig<K extends keyof YASPConfig>(...configs: [K, YASPConfig[K]][]): this;
+    addValue(key: string, value: T): this;
+    changeValue(key: string, value: T): this;
+    removeValue(key: string): this;
+    getValue(key: string): T;
+}
+export {};

package/index.js

@@ -0,0 +1,93 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+exports.__esModule = true;
+var errors = require("./errors.json");
+var warns = require("./warnings.json");
+var defaultYASPConfig = {
+    throwIfNotFound: true
+};
+var YASP = /** @class */ (function () {
+    function YASP(init) {
+        if (init === void 0) { init = {}; }
+        this.config = defaultYASPConfig;
+        this.data = init;
+    }
+    Object.defineProperty(YASP.prototype, "Data", {
+        get: function () {
+            return this.data;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    YASP.prototype.setConfig = function (conf) {
+        this.config = conf;
+        return this;
+    };
+    YASP.prototype.addConfig = function () {
+        var configs = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            configs[_i] = arguments[_i];
+        }
+        for (var _a = 0, configs_1 = configs; _a < configs_1.length; _a++) {
+            var konfig = configs_1[_a];
+            var kkey = konfig[0], kvalue = konfig[1];
+            this.config[kkey] = kvalue;
+        }
+        return this;
+    };
+    YASP.prototype.addValue = function (key, value) {
+        if (key in this.data) {
+            throw new Error(errors.ValueAppending);
+        }
+        this.data[key] = value;
+        return this;
+    };
+    YASP.prototype.changeValue = function (key, value) {
+        if (!(key in this.data)) {
+            throw new Error(errors.ValueNotFound);
+        }
+        this.data[key] = value;
+        return this;
+    };
+    YASP.prototype.removeValue = function (key) {
+        var _this = this;
+        if (!(key in this.data)) {
+            if (this.config.throwIfNotFound) {
+                throw new Error(errors.ValueNotFound);
+            }
+            else {
+                console.warn(warns.ValueNotFound);
+            }
+        }
+        this.data = Object.keys(this.data)
+            .filter(function (k) { return k !== key; })
+            .reduce(function (acc, k) {
+            var _a;
+            return __assign(__assign({}, acc), (_a = {}, _a[k] = _this.data[k], _a));
+        }, {});
+        return this;
+    };
+    YASP.prototype.getValue = function (key) {
+        if (!(key in this.data)) {
+            if (this.config.throwIfNotFound) {
+                throw new Error(errors.ValueNotFound);
+            }
+            else {
+                console.warn(warns.ValueNotFound);
+            }
+        }
+        return this.data[key];
+    };
+    return YASP;
+}());
+exports["default"] = YASP;

package/index.ts

@@ -0,0 +1,71 @@
+import * as errors from "./errors.json"
+import * as warns from "./warnings.json"
+
+type YASPConfig = Partial<{
+    throwIfNotFound: boolean;
+}>
+
+const defaultYASPConfig: YASPConfig = {
+    throwIfNotFound: true
+}
+
+export default class YASP<T> {
+    protected data: Record<string, T>;
+    protected config: YASPConfig = defaultYASPConfig;
+    constructor(init: Record<string, T> = {}) {
+        this.data = init
+    }
+    get Data(): Record<string, T> {
+        return this.data
+    }
+    setConfig(conf: YASPConfig) {
+        this.config = conf
+        return this
+    }
+    addConfig<K extends keyof YASPConfig>(...configs: [ K, YASPConfig[ K ] ][]) {
+        for (let konfig of configs) {
+            const [ kkey, kvalue ] = konfig
+            this.config[ kkey ] = kvalue
+        }
+        return this
+    }
+    addValue(key: string, value: T) {
+        if (key in this.data) {
+            throw new Error(errors.ValueAppending)
+        }
+        this.data[ key ] = value
+        return this
+    }
+    changeValue(key: string, value: T) {
+        if (!(key in this.data)) {
+            throw new Error(errors.ValueNotFound)
+        }
+        this.data[ key ] = value
+        return this
+    }
+    removeValue(key: string) {
+        if (!(key in this.data)) {
+            if (this.config.throwIfNotFound) {
+                throw new Error(errors.ValueNotFound)
+            } else {
+                console.warn(warns.ValueNotFound)
+            }
+        }
+        this.data = Object.keys(this.data)
+            .filter(k => k !== key)
+            .reduce<Record<string, T>>((acc, k) => {
+                return { ...acc, [ k ]: this.data[ k ] }
+            }, {})
+        return this
+    }
+    getValue(key: string){
+        if (!(key in this.data)) {
+            if (this.config.throwIfNotFound) {
+                throw new Error(errors.ValueNotFound)
+            } else {
+                console.warn(warns.ValueNotFound)
+            }
+        }
+        return this.data[key]
+    }
+}

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "yet-another-storage-package",
+  "version": "1.0.0",
+  "description": "YASP is a package for storing data.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  }
+}

package/warnings.json

@@ -0,0 +1,3 @@
+{
+    "ValueNotFound": "WARNING: Value not found, returning undefined..."
+}