@wizhut_tech/wizjs 0.0.8 → 0.1.0

package/__tests__/lang_itertools.test.js

@@ -0,0 +1,21 @@
+const t = require('tap');
+
+const { cycle, fn_cycle } = require('../src/lang/itertools.js');
+
+
+t.test('itertools/cycle', (t) => {
+    // simple integer
+    const genOne = cycle(0, 1);
+    t.equal(genOne.next().value, 0);
+    t.equal(genOne.next().value, 1);
+    t.equal(genOne.next().value, 2);
+
+    // simple floating-point
+    const genTwo = cycle(0, 0.5);
+    t.equal(genTwo.next().value, 0);
+    t.equal(genTwo.next().value, 0.5);
+    t.equal(genTwo.next().value, 1);
+    t.equal(genTwo.next().value, 1.5);
+
+    t.end();
+});

package/docs/io_files.md

@@ -0,0 +1,3 @@
+# Lang / files
+
+* **loadFully(filename)**: loads a *file*, fully and returns it as text. If an error occurs return null 

package/docs/lang_flow.md

@@ -1,3 +1,3 @@
 # Lang / flow
 
-**Still in development**
+* **if_exception(fn, fn_noexc, fn_exc)**: executes *fn*. if it throws an exception then it calls *fn_exc*, else *fn_noexc*. 

package/docs/lang_itertools.md

@@ -0,0 +1,4 @@
+# Lang / itertools
+
+* **cycle(start, step=1)**: A generator that counts from *start* with a specified *step*. Default stepping is *1*.
+* **fn_cycle(start, step=1, fn)**: A generator that counts from *start* with a specified *step*. Default stepping is *1*. For each iteration the *fn* is called. To continue to the next iteration, the *fn* should return *true*. If not the iteration breaks,. 

package/index.js

@@ -3,9 +3,15 @@ const checks = require('./src/lang/checks.js');
 const numbers = require('./src/math/numbers.js');
 const functools = require('./src/lang/functools.js');
 const arrays = require('./src/lang/arrays.js');
+const files = require('./src/io/files.js');
+
+const { BadlyInitializedError } = require('./src/internal/exceptions.js');
 
 
 module.exports = {
+    io: {
+        files: files,
+    },
     lang: {
         arrays: arrays,
         singleton: singleton,
@@ -14,5 +20,8 @@ module.exports = {
     },
     math: {
         numbers: numbers
+    },
+    exceptions: {
+        BadlyInitializedError
     }
 }

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@wizhut_tech/wizjs",
-  "version": "0.0.8",
+  "version": "0.1.0",
   "main": "index.js",
   "devDependencies": {
-    "tap": "21.0.2"
+    "tap": "21.1.0"
   },
   "description": "Simple but useful hacks for everyday javascript programming",
   "scripts": {

package/readme.md

@@ -8,9 +8,13 @@ Use by importing:
 
 ```
 {
+    io: {
+        files: [functions]
+    },
     lang: {
         arrays: [functions],
         checks: [functions],
+        flow: [functions],
         singleton: [functions],
         functools: [functions]
     },
@@ -20,12 +24,21 @@ Use by importing:
 }
 ```
 
+You can also import individual functions like the following snippet:
+
+`const { lang: { checks : { isNil } } }  = require('@wizhut_tech/wizjs');`
+
+### I/O
+
+* **Files** utility functions ... [[docs](docs/io_files.md)]
+
 ### Language
 
 * **Arrays** utility functions ... [[docs](docs/lang_arrays.md)]
 * **Check** utility functions ... [[docs](docs/lang_checks.md)]
-* Control-**Flow** utilities ... [[docs](docs/lang_flow.md)] -- *still in development* --
+* Control-**Flow** utilities ... [[docs](docs/lang_flow.md)]
 * **functools** ... [[docs](docs/lang_functools.md)]
+* **itertools** ... [[docs](docs/lang_itertools.md)]
 * **Singleton** hack ... [[docs](docs/lang_singleton.md)]
 
 ### Math

package/src/internal/exceptions.js

@@ -0,0 +1,12 @@
+
+
+class BadlyInitializedError extends Error {
+    constructor(message, ...args) {
+        super(message);
+    }
+}
+
+
+module.exports = {
+    BadlyInitializedError
+};

package/src/io/files.js

@@ -0,0 +1,15 @@
+const fs = require('fs').promises;
+
+
+async function loadFully(filename) {
+    try {
+        const data = await fs.readFile(filename, 'utf8');
+    } catch (err) {
+        return null;
+    }
+}
+
+
+module.exports = {
+    loadFully
+};

package/src/lang/flow.js

@@ -1,17 +1,15 @@
 
 
-class TransactionItem {
-    constructor(task, fallback) {
-        this.task = task;
-        this.fallback = fallback;
-    }
-
-    async execute() {
-        
+function if_exception(fn, fn_noexc, fn_exc) {
+    try {
+        fn();
+        fn_noexc();
+    } catch (error) {
+        fn_exc(error);
     }
 }
 
 
 module.exports = {
-
+    if_exception
 };

package/src/lang/itertools.js

@@ -0,0 +1,25 @@
+
+const {toInteger} = require("../math/numbers");
+
+
+function* cycle(start=0, step=1) {
+    let iCount = toInteger(start);
+    const iStep = toInteger(step);
+
+    while (true) {
+        yield iCount;
+        iCount += step;
+    }
+}
+
+function fn_cycle(start, fn, step=1) {
+    const cycleGenerator = cycle(start, step);
+
+    while (fn(cycleGenerator.next().value)) { }
+}
+
+
+module.exports = {
+    cycle,
+    fn_cycle
+};