@wizhut_tech/wizjs 0.0.4 → 0.0.6

package/__tests__/lang_checks.test.js

@@ -1,6 +1,7 @@
 const t = require('tap');
 
-const { isNil } = require('../src/lang/checks.js');
+const { isNil, isArray, isObject, isNumber, isString } = require('../src/lang/checks.js');
+
 
 
 t.test('checks/isNil', (t) => {
@@ -10,4 +11,46 @@ t.test('checks/isNil', (t) => {
     t.equal(isNil(1.0), false);
     t.equal(isNil('not-null-string'), false);
     t.end();
-});
+});
+
+t.test('checks/isArray', (t) => {
+    t.equal(isArray([]), true);
+    t.equal(isArray(1), false);
+    t.equal(isArray('misc'), false);
+    t.equal(isArray(null), false);
+    t.equal(isArray(undefined), false);
+    t.equal(isArray({}), false);
+    t.end();
+});
+
+t.test('checks/isObject', (t) => {
+    t.equal(isObject(null), false);
+    t.equal(isObject(undefined), false);
+    t.equal(isObject(1), false);
+    t.equal(isObject('misc'), false);
+    t.equal(isObject({}), true);
+    t.equal(isObject([]), false);
+    t.end();
+});
+
+t.test('checks/isNumber', (t) => {
+    t.equal(isNumber(null), false);
+    t.equal(isNumber(undefined), false);
+    t.equal(isNumber({}), false);
+    t.equal(isNumber([]), false);
+    t.equal(isNumber(1), true);
+    t.equal(isNumber(1.1), true);
+    t.equal(isNumber('misc'), false);
+    t.end();
+});
+
+t.test('checks/isString', (t) => {
+    t.equal(isString(null), false);
+    t.equal(isString(undefined), false);
+    t.equal(isString({}), false);
+    t.equal(isString([]), false);
+    t.equal(isString(1), false);
+    t.equal(isString(1.1), false);
+    t.equal(isString('misc'), true);
+    t.end();
+})

package/__tests__/lang_functools.test.js

@@ -0,0 +1,9 @@
+const t = require('tap');
+
+const { reflexive } = require('../src/lang/functools.js');
+
+
+t.test('functools/reflexive', (t) => {
+    t.equal(reflexive(null), null);
+    t.end();
+});

package/docs/lang_checks.md

@@ -1,5 +1,7 @@
 # Lang / Checks
 
-Import as `require('wizjs/lang/checks.js')`.
-
-* **isNil(arg)**: Check if the `arg` is `undefined` or `null` and returns `true` (or `false` otherwise).
+* **isNil(arg)**: Checks if the `arg` is `undefined` or `null` and returns `true` (or `false` otherwise).
+* **isArray(arg)**: Checks if the `arg` is an `array` and return `true` else `false`
+* **isObject(arg)**: Checks if the `arg` is an `object` and return `true` else `false`
+* **isString(arg)**: Checks if the `arg` is a `string` and return `true` else `false`
+* **isNumber(arg)**: Checks if the `arg` is a `number` and return `true` else `false`

package/docs/lang_functools.md

@@ -0,0 +1,3 @@
+## lang / functools
+
+* **reflexive(arg)**: Just a dumb method that returns `arg` as provided.

package/docs/lang_singleton.md

@@ -1,8 +1,6 @@
 # Lang / Singleton
 
-Import with `require('wizjs/lang/singleton.js')`. In-memory caching of an async function's result, ensuring that it will be called only once.
-
-Mimics similar python decorators. It can easily, be used to store class instance variables.
+In-memory caching of an async function's result, ensuring that it will be called only once. Mimics similar python decorators. It can easily, be used to store class instance variables.
 
 ### Module API
 

package/docs/math_numbers.md

@@ -1,5 +1,3 @@
 # Math / Numbers
 
-Import as `require('wizjs/math/numbers.js')`.
-
 * **toInteger(arg)**: Attempts to convert `arg` to `Integer`. Return `0` if the arg is `zero` or invalid value.

package/index.js

@@ -1,12 +1,14 @@
 const singleton = require('./src/lang/singleton.js');
 const checks = require('./src/lang/checks.js');
 const numbers = require('./src/math/numbers.js');
+const functools = require('./src/lang/functools.js');
 
 
 module.exports = {
     lang: {
         singleton: singleton,
-        checks: checks
+        checks: checks,
+        functools: functools
     },
     math: {
         numbers: numbers

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wizhut_tech/wizjs",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "main": "index.js",
   "devDependencies": {
     "tap": "21.0.1"

package/readme.md

@@ -2,12 +2,30 @@
 
 A Javascript library (a few selected dependencies only) that contains utilities for enjoy-full every day programming. No, this library will not become another `lodash` :).
 
+Use by importing:
+
+`const wizjs = require('@wizhut_tech/wizjs')`. Returns an object structured like:
+
+```
+{
+    lang: {
+        checks: [functions],
+        singleton: [functions],
+        functools: [functions]
+    },
+    math: {
+        numbers: [functions]
+    }
+}
+```
+
 ### Language
 
-* Checks ... [documentation](docs/lang_checks.md)
-* Flow ... [documentation](docs/lang_flow.md)
-* Singleton ... [documentation](docs/lang_singleton.md)
+* **Check** utility functions ... [[docs](docs/lang_checks.md)]
+* Control-**Flow** utilities ... [[docs](docs/lang_flow.md)] -- *still in development* --
+* **functools** ... [[docs](docs/lang_functools.md)]
+* **Singleton** hack ... [[docs](docs/lang_singleton.md)]
 
 ### Math
 
-* Numbers ... [documentation](docs/math_numbers.md)
+* Utilities around **numbers** ... [[docs](docs/math_numbers.md)]

package/src/lang/checks.js

@@ -3,7 +3,37 @@ function isNil(value) {
     return value === null || value === undefined;
 }
 
+function isArray(value) {
+    return Array.isArray(value);
+}
+
+function isObject(value) {
+    if (isNil(value)) {
+        return false;
+    }
+
+    if (isArray(value)) {
+        return false;
+    }
+
+    return typeof value === 'object';
+}
+
+
+function isString(value) {
+    return typeof value === 'string';
+}
+
+
+function isNumber(value) {
+    return typeof value === 'number';
+}
+
 
 module.exports = {
-    isNil
+    isNil,
+    isArray,
+    isObject,
+    isString,
+    isNumber
 }

package/src/lang/functools.js

@@ -0,0 +1,10 @@
+
+
+function reflexive(arg) {
+    return arg;
+}
+
+
+module.exports = {
+    reflexive
+}