added support of top-level getters (#26)

* added support of top-level getters
Breaking Change: all memory values are now stored in _storage_ property

Author: AlexGalichenko

CHANGELOG.MD

@@ -4,6 +4,10 @@ All notable changes to the "@qavajs/memory" will be documented in this file.
 
 Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how to structure this file.
 
+## [1.8.0]
+- :rocket: added support of top-level getters
+Breaking Change: all memory values are now stored in _storage_ property
+
 ## [1.7.1]
 - :rocket: improved error handling to produce more clear errors
 

index.d.ts

@@ -3,12 +3,42 @@ declare interface Logger {
 }
 
 declare type Memory = {
+    /**
+     * Register memory map
+     * @param memoryMap
+     * @example
+     * memory.register({
+     *     key1: 'value1',
+     *     key2: 42
+     *     key3: {
+     *         property: 12
+     *     }
+     * })
+     */
     register(memoryMap: Object): void;
+    /**
+     * Set value to memory
+     * @param key
+     * @param value
+     * @example
+     * memory.setValue('key', 'value');
+     */
     setValue(key: string, value: any): void;
-    getValue(key: string): any;
+    /**
+     * Get value from memory
+     * @param key
+     * @example
+     * const value = memory.getValue('key');
+     */
+    getValue(key: any): any;
+    /**
+     * Set logger
+     * @param logger
+     */
     setLogger(logger: Logger): void;
 }
 declare const memory: Memory;
 declare module '@qavajs/memory' {
     export default memory
 }
+export default memory;

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qavajs/memory",
-  "version": "1.7.1",
+  "version": "1.8.0",
   "description": "memory package for @qavajs framework",
   "main": "index.js",
   "scripts": {

src/memory.ts

@@ -26,7 +26,7 @@ function toString(value: any): string {
 
 class Memory {
 
-    [prop: string]: any;
+    storage: { [key: string]: any } = {};
     logger: { log: (value: any) => void } = { log() {} };
 
     /**
@@ -74,7 +74,7 @@ class Memory {
      */
     @readonly
     setValue(key: string, value: any) {
-        this[key] = value;
+        this.storage[key] = value;
     }
 
     /**
@@ -90,7 +90,7 @@ class Memory {
                 .replace(UNESCAPE_DOLLAR_REGEXP, '$')
         );
         try {
-            return getFunction.apply(this);
+            return getFunction.apply(this.storage);
         } catch (err: any) {
             this.reportError(err);
         }
@@ -102,28 +102,18 @@ class Memory {
      */
     @readonly
     register(obj: { [prop: string]: any }) {
-        for (const prop in obj) {
-            this[prop] = obj[prop];
+        this.storage = obj;
+        this.storage.js = function(expression: any) {
+            return expression;
         }
     }
 
-    /**
-     * Evaluate js expression
-     * @param {any} expression - expression to evaluate
-     * @example $js($val + 1)
-     */
-    @readonly
-    js(expression: any) {
-        return expression;
-    }
-
     @readonly
     setLogger(logger: { log: (value: any) => void }) {
         this.logger = logger;
     }
 
-    @readonly
-    reportError(err: any) {
+    private reportError(err: any) {
         err.message = err.message.replace(/this\./g, '$');
         throw err;
     }

tests/dataTypes.spec.ts

@@ -1,6 +1,10 @@
-import {test, expect} from 'vitest';
+import {test, expect, beforeEach} from 'vitest';
 import memory from '../src/memory';
 
+beforeEach(() => {
+    memory.register({});
+});
+
 test('number', () => {
     expect(memory.getValue('$js(1)')).to.equal(1);
 });

tests/memory.spec.ts

@@ -1,40 +1,44 @@
-import {test, expect} from 'vitest';
+import {beforeEach, test, expect} from 'vitest';
 import memory from '../src/memory';
 
+beforeEach(() => {
+    memory.register({});
+});
+
 test('computed without params returns value', () => {
-    memory.computed = function () {
+    memory.storage.computed = function () {
         return 42
     }
 
     expect(memory.getValue('$computed()')).to.equal(42);
 });
 
 test('computed with number param returns value', () => {
-    memory.computed = function (val: any) {
+    memory.storage.computed = function (val: any) {
         return val
     }
 
     expect(memory.getValue('$computed(42)')).to.equal(42);
 });
 
 test('computed with string param returns value', () => {
-    memory.computed = function (val: any) {
+    memory.storage.computed = function (val: any) {
         return val
     }
 
     expect(memory.getValue('$computed("test string")')).to.equal("test string");
 });
 
 test('computed with memory param returns value', () => {
-    memory.computed = function (val1: any, val2: any, val3: any) {
+    memory.storage.computed = function (val1: any, val2: any, val3: any) {
         return val1 + val2 + val3
     }
 
-    memory.anotherComputed = function () {
+    memory.storage.anotherComputed = function () {
         return 42
     }
 
-    memory.someVal = 42;
+    memory.storage.someVal = 42;
 
     expect(memory.getValue('$computed(42, $anotherComputed(), $someVal)')).to.equal(126);
 });
@@ -54,15 +58,15 @@ test('simple string returns as is', () => {
 // Query tests
 
 test('query string with one existing variable', () => {
-    memory.num = 1;
+    memory.storage.num = 1;
     const queryString = 'Component > #{$num} of Collection'
     const expected = `Component > #1 of Collection`;
     expect(memory.getValue(queryString)).to.equal(expected);
 });
 
 test('query string with two existing variables', () => {
-    memory.ind1 = 1;
-    memory.ind2 = 15;
+    memory.storage.ind1 = 1;
+    memory.storage.ind2 = 15;
     const queryString = 'Component > #{$ind1} of Collection1 > #{$ind2} of Collection2'
     const expected = `Component > #1 of Collection1 > #15 of Collection2`;
     expect(memory.getValue(queryString)).to.equal(expected);
@@ -298,7 +302,6 @@ test('interpolation without memory values', () => {
 });
 
 test('non string input', () => {
-    //@ts-ignore
     expect(memory.getValue(42)).to.equal(42);
 });
 
@@ -311,6 +314,15 @@ test('correct error message', () => {
     expect(() => memory.getValue('$x()')).toThrow('$x is not a function');
 });
 
+test('getter', () => {
+    let closure = 1;
+    memory.register({
+        get x() { return closure++ }
+    });
+    expect(memory.getValue('$x')).to.equal(1);
+    expect(memory.getValue('$x')).to.equal(2);
+});
+
 
 
 

tests/memory_singleton.cjs

@@ -1,3 +1,3 @@
 const memory = require('../index');
 
-memory.singletonVal = 'singleton cjs';
+memory.setValue('singletonVal', 'singleton cjs');

tests/memory_singleton.mjs

@@ -1,3 +1,3 @@
 import memory from '../index.js';
 
-memory.singletonVal = 'singleton mjs';
+memory.setValue('singletonVal', 'singleton mjs');