binaryarray - npm Package Compare versions

Comparing version 0.1.0 to 0.1.1

example/ex_admin_flag.js

+"use strict"
+const BinaryArray = require('..')
+const getMax = (spec) => Object.keys(spec).reduce((r, k) => Math.max(r, spec[k]), 0) + 1
+const ROLE = {
+    ADMIN_MANAGER : 0,
+    DEVELOPPER : 1,
+    BUSINESS_OWNER : 2,
+    CUSTOMER_SUPPORT_VIEW : 3,
+    CUSTOMER_SUPPORT_UPDATE : 4,
+}
+const ROLE_MAX = getMax(ROLE)
+
+const ba = new BinaryArray(ROLE_MAX)
+for(let i = 0; i < ROLE_MAX; ++i){
+    ba.bitOn(i)
+}
+
+if(ba.at(ROLE.ADMIN_MANAGER)){
+    console.log("ADMIN")
+}
+
+console.log(ba.serialize(ROLE))
+console.log(ba.toArray(ROLE).join(""))
+

example/ex1.js

+var BinaryArray = require('..');
+
+var EVENT_CLEAR = {
+    TUTORIAL : 0,
+    QUEST1 : 1,
+    QUEST2 : 2,
+    QUEST3 : 3,
+    QUEST4 : 4,
+    QUEST5 : 5,
+    QUEST6 : 6,
+    LASTBOSS : 7,
+}
+var EVENT_CLEAR_MAX = Object.keys(EVENT_CLEAR).reduce(function(r, k){ return Math.max(EVENT_CLEAR[k], r) }, 0) + 1;
+
+var ba = new BinaryArray(EVENT_CLEAR_MAX)
+
+ba.bitOn(EVENT_CLEAR.TUTORIAL);
+ba.bitOn(EVENT_CLEAR.QUEST1);
+ba.bitOn(EVENT_CLEAR.QUEST4);
+
+var save = ba.toArray();
+var ba2 = BinaryArray.loadFromArray(save);
+console.log(save);
+console.log(ba2.toArray());
+
+ba2.bitOn(2);
+ba2.bitOn(3);
+ba2.bitOff(4);
+console.log(ba.toHexString())
+console.log(ba2.toHexString())
+
+
+if(ba.at(EVENT_CLEAR.QUEST4)) console.log("ok")
+if(!ba2.at(EVENT_CLEAR.QUEST4)) console.log("ok")

example/ex2.js

+var BinaryArray = require('..');
+
+var EVENT_CLEAR = {
+    TUTORIAL : 0,
+    QUEST1 : 1,
+    QUEST2 : 2,
+    QUEST3 : 3,
+    QUEST4 : 4,
+    QUEST5 : 5,
+    QUEST6 : 6,
+    LASTBOSS : 7,
+}
+var EVENT_CLEAR_MAX = Math.max.apply(Math, Object.keys(EVENT_CLEAR).map(function(k){ return EVENT_CLEAR[k] })) + 1;
+
+var ba = new BinaryArray(EVENT_CLEAR_MAX)
+
+ba.bitOn(EVENT_CLEAR.TUTORIAL);
+ba.bitOn(EVENT_CLEAR.QUEST1);
+ba.bitOn(EVENT_CLEAR.QUEST4);
+
+var serialize = ba.serialize(EVENT_CLEAR);
+console.log(serialize);
+
+var ba2 = BinaryArray.deserialize(serialize, EVENT_CLEAR, EVENT_CLEAR_MAX);
+console.log(ba2.serialize(EVENT_CLEAR));
+

example/ex3.js

+var BinaryArray = require('..');
+
+var EVENT_CLEAR = {
+    TUTORIAL : 0,
+    QUEST1 : 1,
+    QUEST2 : 2,
+    QUEST3 : 3,
+    QUEST4 : 4,
+    QUEST5 : 5,
+    QUEST6 : 6,
+    LASTBOSS : 7,
+}
+var EVENT_CLEAR_MAX = Math.max.apply(Math, Object.keys(EVENT_CLEAR).map(function(k){ return EVENT_CLEAR[k] })) + 1;
+
+var ba = new BinaryArray(EVENT_CLEAR_MAX)
+
+ba.bitOn(EVENT_CLEAR.TUTORIAL);
+ba.bitOn(EVENT_CLEAR.QUEST1);
+ba.bitOn(EVENT_CLEAR.QUEST2);
+ba.bitOn(EVENT_CLEAR.QUEST3);
+ba.bitOn(EVENT_CLEAR.QUEST4);
+ba.bitOff(EVENT_CLEAR.QUEST6);
+ba.bitOff(EVENT_CLEAR.LASTBOSS);
+
+if(ba.check([
+    EVENT_CLEAR.QUEST1,
+    EVENT_CLEAR.QUEST2,
+    EVENT_CLEAR.QUEST3,
+    EVENT_CLEAR.QUEST4
+],[
+    EVENT_CLEAR.QUEST6,
+    EVENT_CLEAR.LASTBOSS
+])){
+    console.log("GO LAST BOSS");
+}else{
+    console.log("BOO");
+}
+
+

example/ex4.js

+"use strict"
+const BinaryArray = require('..')
+
+const JOB = Object.freeze({
+    NONE : 0,
+    FIGHTER : 1,
+    MAGE : 2,
+    PRIEST : 3,
+    MONK : 4,
+    KNIGHT : 5,
+    SUMMONER : 6,
+});
+
+const JOB_MAX = Object.keys(JOB).reduce((r, k) => Math.max(r, JOB[k]), 0) + 1;
+
+let JOB_GROUP = {
+    TANK : BinaryArray.deserialize([
+        'FIGHTER',
+        'MONK',
+        'KNIGHT'
+    ], JOB, JOB_MAX),
+    CASTER : BinaryArray.deserialize([
+        'MAGE',
+        'PRIEST',
+        'SUMMONER'
+    ], JOB, JOB_MAX),
+    HEALER : BinaryArray.deserialize([
+        'PRIEST'
+    ], JOB, JOB_MAX),
+    EXJOB : BinaryArray.deserialize([
+        'SUMMONER',
+        'KNIGHT'
+    ], JOB, JOB_MAX),
+}
+
+let job_id = JOB.FIGHTER;
+if( JOB_GROUP.TANK.at(job_id) ){
+    console.log("tank job")
+}else{
+    console.log("not tank job")
+}
+

example/ex5.js

+"use strict"
+const BinaryArray = require('..')
+
+const JOB = Object.freeze({
+    NONE : 0,
+    FIGHTER : 1,
+    MAGE : 2,
+    PRIEST : 3,
+    MONK : 4,
+    KNIGHT : 5,
+    SUMMONER : 6,
+});
+
+const JOB_MAX = Object.keys(JOB).reduce((r, k) => Math.max(r, JOB[k]), 0) + 1;
+
+let ba = new BinaryArray(JOB_MAX);
+ba.bitOn(JOB.FIGHTER);
+ba.bitOn(JOB.PRIEST);
+let save = ba.serialize(JOB);
+console.log(save);
+
+let ba2 = BinaryArray.deserialize(save, JOB, JOB_MAX);
+console.log(ba2.serialize(JOB));
+

example/ex6.js

+"use strict"
+const BinaryArray = require('..')
+
+const JOB = Object.freeze({
+    NONE : 0,
+    FIGHTER : 1,
+    MAGE : 2,
+    PRIEST : 3,
+    MONK : 4,
+    KNIGHT : 5,
+    SUMMONER : 6,
+});
+
+const JOB_MAX = Object.keys(JOB).reduce((r, k) => Math.max(r, JOB[k]), 0) + 1;
+
+let ba = new BinaryArray(JOB_MAX);
+ba.bitOn(JOB.FIGHTER);
+ba.bitOn(JOB.PRIEST);
+if(ba.check([JOB.FIGHTER, JOB.PRIEST], [JOB.KNIGHT])){
+    ba.bitOn(JOB.KNIGHT);
+    console.log("EXJOB GET")
+}
+let save = ba.serialize(JOB);
+console.log(save);
+
+let ba2 = BinaryArray.deserialize(save, JOB, JOB_MAX);
+if(ba2.check([JOB.FIGHTER, JOB.PRIEST], [JOB.KNIGHT])){
+    ba2.bitOn(JOB.KNIGHT);
+    console.log("EXJOB GET")
+}
+console.log(ba2.serialize(JOB));
+

src/index.ts

+import { BinaryArray } from './lib/binaryarray'
+export = BinaryArray
+

src/lib/binaryarray.ts

+import assert = require('assert');
+import util = require('./util');
+
+export class BinaryArray{
+    maxnum: number;
+    storage: Uint32Array;
+    constructor(maxnum : number){
+        this.maxnum = maxnum
+        this.storage = util.createArray(util.getArraySize(maxnum), 0)
+    }
+    bitOn(no : number) : BinaryArray{
+        assert(this.maxnum > no, 'on:over flagmax');
+        const idx = util.getArrayIndex(no);
+        assert(idx >= 0 && idx < this.storage.length, 'on:over idx range');
+        const pos = util.getFlagPos(no);
+        const flag = 1 << pos;
+        this.storage[idx] |= flag;
+        return this;
+    }
+    bitOff(no : number) : BinaryArray{
+        assert(this.maxnum > no, 'off:over flagmax');
+        const idx = util.getArrayIndex(no);
+        assert(idx >= 0 && idx < this.storage.length, 'off:over idx range');
+        const pos = util.getFlagPos(no);
+        const flag = 1 << pos;
+        if(this.storage[idx] & flag){
+            this.storage[idx] ^= flag;
+        }
+        return this;
+    }
+    at(no : number) : number{
+        assert(this.maxnum > no, 'get:over flagmax');
+        const idx = util.getArrayIndex(no);
+        assert(idx >= 0 && idx < this.storage.length, 'is:over idx range');
+        const pos = util.getFlagPos(no);
+        const flag = 1 << pos;
+        return this.storage[idx] & flag ? 1 : 0;
+    }
+    toArray() : Array<number>{
+        const w = [];
+        const max = this.maxnum;
+        for(let i = 0; i < max; ++i ){
+            w.push(this.at(i));
+        }
+        return w;
+    }
+    serialize(spec : Object) : Array<string>{
+        assert(spec instanceof Object, 'spec is must be Object')
+        const w = this.toArray();
+        return Object.keys(spec)
+            .filter((k) => w[spec[k]])
+            .map((k) => k)
+    }
+    toJSON() : string{
+        return JSON.stringify(this.toArray())
+    }
+    isRange(no : number) : boolean{
+        if(!(this.maxnum > no)){
+                return false;
+        }
+        const idx = util.getArrayIndex(no);
+        if(!(idx >= 0 && idx < this.storage.length)){
+            return false;
+        }
+        return true;
+    }
+    rangeOf(xs :  any) : Object{
+        if(!(xs instanceof Array)){
+            xs = [xs];
+        }
+        return xs.reduce((r, v) => {
+            r[v] = this.at(v)
+            return r;
+        }, {})
+    }
+    check(on_list : Array<number>, off_list : Array<number> = []) : boolean{
+        const on = this.rangeOf(on_list);
+        const off = this.rangeOf(off_list);
+        const x = Object.keys(on).reduce((r, v) => { return r & on[v] }, 1)
+        const y = Object.keys(off).reduce((r, v) => { return r & ~off[v] }, 1)
+        return (x & y) ? true : false
+    }
+    toHexString() : string{
+        let str = '';
+        const n = this.storage.length;
+        for(let i=n-1;i>=0;--i){
+            str = str + util.NumberToHexString(this.storage[i], 8);
+        }
+        return str;
+    }
+    static loadFromHexString(maxnum : number, str : string) : BinaryArray{
+        const ba = new BinaryArray(maxnum);
+        const s = 8;
+        let b   = str.length - s;
+        let e   = str.length - 0;
+        const n = str.length / s;
+        for(let i = 0; i < n; ++i){
+            ba.storage[i] = parseInt(str.substring(b,e), 16);
+            b -= s;
+            e -= s;
+        }
+        return ba;
+    }
+    static loadFromArray(xs : Array<number>) : BinaryArray{
+        const ba = new BinaryArray(xs.length);
+        xs.map((v, i) => [v, i])
+            .filter((v) => v[0])
+            .forEach((v) => {
+                ba.bitOn(v[1]);
+            })
+        return ba;
+    }
+    static deserialize(list : Array<string>, spec : Object, max : number) : BinaryArray{
+        const ba = new BinaryArray(max);
+        list.forEach((v) => { ba.bitOn(spec[v]) })
+        return ba;
+    }
+}

src/lib/util.ts

+
+// 配列一つに入るビットの数
+const BITS : number = 32;
+
+// フラグ数から配列のサイズを求める
+export const getArraySize = (flagmax : number) : number => {
+    return Math.ceil(flagmax/BITS);
+}
+
+// フラグ番号から配列の位置を求める
+export const getArrayIndex = (no : number) : number => {
+    return Math.floor(no/BITS);
+}
+
+// フラグ番号から実際のフラグの位置を求める
+export const getFlagPos = (no : number) : number => {
+    return no % BITS;
+}
+
+
+export const digitfix = (str : string, b : number) : string => {
+    if(str.length < b ){
+        const len = b - str.length;
+        for(let i = 0; i < len; ++i){
+            str = '0' + str;
+        }
+    }
+    return str;
+};
+
+export const hexconv = (n : number) : string => {
+    switch (n) {
+        case 10: return 'A';
+        case 11: return 'B';
+        case 12: return 'C';
+        case 13: return 'D';
+        case 14: return 'E';
+        case 15: return 'F';
+    }
+    return n.toString();
+};
+
+// 数値からヘックスの文字列にする
+export const NumberToHexString = (num : number, digit : number) : string => {
+    let remainder = 0;
+    let str = '';
+    while (num > 0) {
+        remainder = num % 16;
+        num = (num - remainder) / 16;
+        str = hexconv(remainder) + str;
+    }
+    return digitfix(str, digit);
+}
+
+// 初期化済みの配列を作成する
+export const createArray = (size : number, init_val : number = 0) : Uint32Array => {
+    const w = new Uint32Array(size);
+    for(let i = 0; i < size; ++i){
+        w[i] = init_val;
+    }
+    return w;
+}
+
+export const getSpecMax = (spec : Object) : number => {
+    return Object.keys(spec).reduce((r, k) => Math.max(r, spec[k]), 0) + 1
+}
+
+

src/test/binaryarray.test.ts

+import assert = require('assert');
+import BinaryArray = require('..');
+import {getSpecMax} from "../lib/util"
+
+describe('test', () => {
+    it('array length test',() => {
+        [
+        ()=>{
+            const ba = new BinaryArray(0);
+            assert(ba.maxnum === 0);
+            assert(ba.storage.length === 0);
+        },
+        ()=>{
+            const ba = new BinaryArray(1);
+            assert(ba.maxnum === 1);
+            assert(ba.storage.length === 1);
+        },
+        ()=>{
+            const ba = new BinaryArray(32);
+            assert(ba.maxnum === 32);
+            assert(ba.storage.length === 1);
+        },
+        ()=>{
+            const ba = new BinaryArray(33);
+            assert(ba.maxnum === 33);
+            assert(ba.storage.length === 2);
+        },
+        ()=>{
+            const ba = new BinaryArray(64);
+            assert(ba.maxnum === 64);
+            assert(ba.storage.length === 2);
+        },
+        ()=>{
+            const ba = new BinaryArray(65);
+            assert(ba.maxnum === 65);
+            assert(ba.storage.length === 3);
+        }].forEach((f) => { f() })
+    });
+    it('binary on test', () => {
+        [
+        ()=>{
+            const ba = new BinaryArray(32);
+            assert(ba.storage[0] === 0x00000000);
+        },
+        ()=>{
+            const ba = new BinaryArray(32);
+            ba.bitOn(0);
+            assert(ba.storage[0] === 0x00000001);
+            assert(ba.at(0) === 1);
+        },
+        ()=>{
+            const ba = new BinaryArray(32);
+            ba.bitOn(0);
+            ba.bitOn(1);
+            assert(ba.storage[0] === 0x00000003);
+            assert(ba.at(0) === 1);
+            assert(ba.at(1) === 1);
+        },
+        ()=>{
+            const ba = new BinaryArray(32);
+            ba.bitOn(0);
+            ba.bitOn(1);
+            ba.bitOn(2);
+            assert(ba.storage[0] === 0x00000007);
+            assert(ba.at(0) === 1);
+            assert(ba.at(1) === 1);
+            assert(ba.at(2) === 1);
+        },
+        ()=>{
+            const ba = new BinaryArray(32);
+            ba.bitOn(31);
+            assert(ba.storage[0] === 0x80000000);
+            assert(ba.at(31) === 1);
+        },
+        ()=>{
+            const ba = new BinaryArray(33);
+            ba.bitOn(32);
+            assert(ba.storage[0] === 0x00000000);
+            assert(ba.storage[1] === 0x00000001);
+            assert(ba.at(31) === 0);
+            assert(ba.at(32) === 1);
+        },
+        ()=>{
+            const ba = new BinaryArray(32);
+            ba.bitOn(0);
+            assert(ba.storage[0] === 0x00000001);
+            ba.bitOn(0);
+            assert(ba.storage[0] === 0x00000001);
+        }].forEach((f) => { f() })
+    });
+    it('binary off test', () => {
+        [
+        ()=>{
+            const ba = new BinaryArray(32);
+            ba.storage[0] = 0xffffffff;
+            ba.bitOff(0);
+            assert(ba.storage[0] === 0xfffffffe);
+            assert(ba.at(0) === 0);
+            assert(ba.at(1) === 1);
+        },
+        ()=>{
+            const ba = new BinaryArray(32);
+            ba.storage[0] = 0xffffffff;
+            ba.bitOff(31);
+            assert(ba.storage[0] === 0x7fffffff);
+            assert(ba.at(0) === 1);
+            assert(ba.at(30) === 1);
+            assert(ba.at(31) === 0);
+        },
+        ()=>{
+            const ba = new BinaryArray(64);
+            ba.storage[0] = 0xffffffff;
+            ba.storage[1] = 0xffffffff;
+            ba.bitOff(32);
+            assert(ba.storage[0] === 0xffffffff);
+            assert(ba.storage[1] === 0xfffffffe);
+            assert(ba.at(31) === 1);
+            assert(ba.at(32) === 0);
+            assert(ba.at(33) === 1);
+        },
+        ()=>{
+            const ba = new BinaryArray(32);
+            ba.storage[0] = 0xfffffffe;
+            ba.bitOff(0);
+            assert(ba.storage[0] === 0xfffffffe);
+            ba.bitOff(0);
+            assert(ba.storage[0] === 0xfffffffe);
+        }].forEach((f) => { f() })
+    });
+    it('if array test', () => {
+        [
+        ()=>{
+            const input = [1,1,1,1,1,1,1,1];
+            const ba = BinaryArray.loadFromArray(input);
+            assert(ba.maxnum === 8);
+            assert(ba.storage[0] === 0x000000ff);
+            const output = ba.toArray();
+            assert(JSON.stringify(input) === JSON.stringify(output));
+        },
+        ()=>{
+            const input = [
+                1,1,1,1,1,1,1,1,
+                1,1,1,1,1,1,1,1,
+                1,1,1,1,1,1,1,1,
+                1,1,1,1,1,1,1,1,
+                1,1,1,1,1,1,1,1
+            ];
+            const ba = BinaryArray.loadFromArray(input);
+            assert(ba.maxnum === input.length);
+            assert(ba.storage[0] === 0xffffffff);
+            assert(ba.storage[1] === 0x000000ff);
+            const output = ba.toArray();
+            assert(JSON.stringify(input) === JSON.stringify(output));
+        }].forEach((f) => { f() })
+    });
+    it('if serialize test', () => {
+        [
+        ()=>{
+            const SPEC = {};
+            for(let i = 0; i<33; i++){ SPEC['TEST_'+(i+1)] = i }
+            const input = ['TEST_1','TEST_2','TEST_33'];
+            const SPEC_MAX = getSpecMax(SPEC);
+            const ba = BinaryArray.deserialize(input, SPEC, SPEC_MAX);
+            assert(ba.maxnum === SPEC_MAX);
+            assert(ba.storage[0] === 0x00000003);
+            assert(ba.storage[1] === 0x00000001);
+            const output = ba.serialize(SPEC);
+            assert(JSON.stringify(input) === JSON.stringify(output));
+        }].forEach((f) => { f() })
+    });
+    it('if other test', () => {
+        [
+        ()=>{
+            const input = [
+                1,1,1,1,1,1,1,1,
+                1,1,1,1,1,1,1,1,
+                1,1,1,1,1,1,1,1,
+                1,1,1,1,1,1,1,1
+            ];
+            const ba = BinaryArray.loadFromArray(input);
+            assert(ba.toHexString() === 'FFFFFFFF');
+        },
+        ()=>{
+            const input = [
+                1,0,0,0,0,0,0,0,
+                0,1,0,0,0,0,0,0,
+                0,0,1,0,0,0,0,0,
+                0,0,0,1,0,0,0,0,
+                0,0,0,0,1,0,0,0,
+                0,0,0,0,0,1,0,0,
+                0,0,0,0,0,0,1,0,
+                0,0,0,0,0,0
+            ];
+            const ba = BinaryArray.loadFromArray(input);
+            assert(ba.toHexString() === '0040201008040201');
+        },
+        ()=>{
+            const ba = BinaryArray.loadFromHexString(32, 'FFFFFFFF');
+            assert(ba.toHexString() === 'FFFFFFFF');
+        },
+        ()=>{
+            const input = [1,0,1,0,1,0,1];
+            const ba = BinaryArray.loadFromArray(input);
+            const json = ba.toJSON()
+            assert(json === JSON.stringify(input));
+        }].forEach((f) => { f() })
+    });
+    it('other test', () => {
+        [
+        ()=>{
+            const ba = new BinaryArray(1024);
+            [0,1,2,3,4,5,10].forEach((v) => { ba.bitOn(v) });
+            assert(ba.check([0,1,2,3,4,5]))
+            assert(!ba.check([0,1,2,3,4,5], [10]))
+            assert(ba.check([0,1,2,3,4,5],[7,8,9]))
+        },
+        ()=>{
+            const ba = new BinaryArray(1024);
+            ba.bitOn(3);
+            const obj = ba.rangeOf([0,1,2,3,4,5]);
+            assert(!obj[0]);
+            assert(obj[3]);
+        },
+        ()=>{
+            const ba = new BinaryArray(1024);
+            ba.bitOn(3);
+            const obj = ba.rangeOf(3);
+            assert(obj[3]);
+        },
+        ()=>{
+            let flag = 1;
+            const ba = new BinaryArray(1024);
+            ba.bitOn(3);
+            try{
+                const obj = ba.rangeOf("AAA");
+            }catch(e){
+                flag = 0;
+            }
+            assert(flag === 0);
+        },
+        ()=>{
+            const ba = new BinaryArray(1024);
+            assert(ba.isRange(1023));
+            assert(!ba.isRange(1024));
+            assert(!ba.isRange(-1));
+        }].forEach((f) => { f() })
+    });
+});
+
+

package.json

 {
   "name": "binaryarray",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "the binary array",
@@ -8,3 +8,7 @@ "main": "dist/index.js",
   "files": [
-    "dist/"
+    "dist",
+    "src",
+    "example",
+    "package.json",
+    "README.md"
   ],
@@ -11,0 +15,0 @@ "repository": {

README.md

@@ -65,2 +65,41 @@ # binaryarray
 
+* typescript
+
+```
+import BinaryArray = require('binaryarray')
+import {getSpecMax} from 'binaryarray/dist/lib/util';
+
+const EVENT_CLEAR = {
+    TUTORIAL : 0,
+    QUEST1 : 1,
+    QUEST2 : 2,
+    QUEST3 : 3,
+    QUEST4 : 4,
+    QUEST5 : 5,
+    QUEST6 : 6,
+    LASTBOSS : 7,
+}
+const EVENT_CLEAR_MAX = getSpecMax(EVENT_CLEAR);
+
+const ba = new BinaryArray(EVENT_CLEAR_MAX)
+
+ba.bitOn(EVENT_CLEAR.TUTORIAL);
+ba.bitOn(EVENT_CLEAR.QUEST1);
+ba.bitOn(EVENT_CLEAR.QUEST4);
+
+const save = ba.toArray();
+const ba2 = BinaryArray.loadFromArray(save);
+console.log(save);
+console.log(ba2.toArray());
+
+ba2.bitOn(2);
+ba2.bitOn(3);
+ba2.bitOff(4);
+console.log(ba.toHexString())
+console.log(ba2.toHexString())
+
+if(ba.at(EVENT_CLEAR.QUEST4)) console.log("ok")
+if(!ba2.at(EVENT_CLEAR.QUEST4)) console.log("ok")
+```
+
 ### application2
@@ -113,1 +152,2 @@
 ```
+

Fixed alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

39989

92.28%

Number of package files

22

100%

Lines of code

1070

130.11%

Number of lines in readme file

152

35.71%

Number of medium supply chain risk alerts

0

-100%

No dependency changes