not-bulma 1.2.16 → 1.2.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "not-bulma",
-  "version": "1.2.16",
+  "version": "1.2.17",
   "description": "not-* family UI components on Bulma CSS Framework",
   "main": "src/index.js",
   "svelte": "src/index.js",

package/src/elements/various/ui.indicator.svelte

@@ -1,67 +1,68 @@
 <script>
-  import {onMount} from 'svelte';
-  import notCommon from '../../frame/common';
-  //if we want to address this indicator
-  export let id = 'tagId';
+    import { onMount } from "svelte";
+    import notCommon from "../../frame/common";
+    //if we want to address this indicator
+    export let id = "tagId";
 
-  export let state = 'light';
-  export let size = 'normal';
-  export let labels = {
-    black: 'black',
-    dark: 'dark',
-    light: 'light',
-    white: 'white',
-    primary: 'primary',
-    link: 'link',
-    info: 'info',
-    success: 'success',
-    warning: 'warning',
-    danger: 'danger'
-  };
-  export let classes = 'mx-1';
+    export let state = "light";
+    export let size = "normal";
+    export let labels = {
+        black: "black",
+        dark: "dark",
+        light: "light",
+        white: "white",
+        primary: "primary",
+        link: "link",
+        info: "info",
+        success: "success",
+        warning: "warning",
+        danger: "danger",
+    };
+    export let classes = "mx-1";
 
-  export let padding = 'normal';
-  export let bold = false;
+    export let padding = "normal";
+    export let bold = false;
 
-  export let right = false;
-  export let left = false;
-  export let top = false;
-  export let bottom = false;
+    export let right = false;
+    export let left = false;
+    export let top = false;
+    export let bottom = false;
 
-  let sided = false;
-  $: sided = right || left || top || bottom;
+    let sided = false;
+    $: sided = right || left || top || bottom;
 
+    export let events = {}; //events to react on
+    //register event handlers
+    export let register = notCommon.registerWidgetEvents.bind(notCommon);
+    //
+    export let onUpdate = (data) => {
+        if (Object.hasOwn(data, "state")) {
+            state = data.state;
+        }
+    };
 
-  export let events = {};        //events to react on
-  //register event handlers
-  export let register = notCommon.registerWidgetEvents.bind(notCommon);
-  //
-  export let onUpdate = (data)=>{
-    if (Object.prototype.hasOwnProperty.call(data, 'state')){
-      state = data.state;
+    function getStandartUpdateEventName() {
+        return `indicator-${id}:update`;
     }
-  };
 
-  function getStandartUpdateEventName(){
-    return `indicator-${id}:update`;
-  }
-
-  onMount(()=>{
-    if (!Object.prototype.hasOwnProperty.call(events, getStandartUpdateEventName())){
-      events[getStandartUpdateEventName()] = onUpdate;
-    }
-    register(events);
-  });
+    onMount(() => {
+        if (!Object.hasOwn(events, getStandartUpdateEventName())) {
+            events[getStandartUpdateEventName()] = onUpdate;
+        }
+        register(events);
+    });
 </script>
 
-<span class="tag
+<span
+    class="tag
 is-{size}
-{bold?'has-text-weight-bold':''}
-{padding!=='normal'?`is-padded-${padding}`:''}
-{sided?'is-sided':''}
-{right?'is-sided-right':''}
-{left?'is-sided-left':''}
-{top?'is-sided-top':''}
-{bottom?'is-sided-bottom':''}
+{bold ? 'has-text-weight-bold' : ''}
+{padding !== 'normal' ? `is-padded-${padding}` : ''}
+{sided ? 'is-sided' : ''}
+{right ? 'is-sided-right' : ''}
+{left ? 'is-sided-left' : ''}
+{top ? 'is-sided-top' : ''}
+{bottom ? 'is-sided-bottom' : ''}
   is-{state} {classes}
-  ">{labels[state]}</span>
+  ">{labels[state]}</span
+>

package/src/elements/various/ui.user.card.svelte

@@ -1,58 +1,56 @@
 <script>
-  import {onMount} from 'svelte';
-  import notCommon from '../../frame/common';
-
-  export let id = 'userCard';
-  export let image = 'https://bulma.io/images/placeholders/32x32.png';
-  export let username = 'John Doe';
-  export let role = 'admin';
-
-  export let events = {};        //events to react on
-  //register event handlers
-  export let register = notCommon.registerWidgetEvents;
-  //
-  export let onUpdate = (data)=>{
-    if (Object.prototype.hasOwnProperty.call(data, 'username')){
-      username = data.username;
+    import { onMount } from "svelte";
+    import notCommon from "../../frame/common";
+
+    export let id = "userCard";
+    export let image = "https://bulma.io/images/placeholders/32x32.png";
+    export let username = "John Doe";
+    export let role = "admin";
+
+    export let events = {}; //events to react on
+    //register event handlers
+    export let register = notCommon.registerWidgetEvents;
+    //
+    export let onUpdate = (data) => {
+        if (Object.hasOwn(data, "username")) {
+            username = data.username;
+        }
+
+        if (Object.hasOwn(data, "role")) {
+            role = data.role;
+        }
+    };
+
+    function getCompId() {
+        return `usercard-${id}`;
     }
 
-    if (Object.prototype.hasOwnProperty.call(data, 'role')){
-      role = data.role;
+    function getStandartUpdateEventName() {
+        let compId = getCompId();
+        return `${compId}:update`;
     }
 
-  };
-
-  function getCompId(){
-    return `usercard-${id}`;
-  }
-
-  function getStandartUpdateEventName(){
-    let compId = getCompId();
-    return `${compId}:update`;
-  }
-
-  onMount(()=>{
-    if (!Object.prototype.hasOwnProperty.call(events, getStandartUpdateEventName())){
-      events[getStandartUpdateEventName()] = onUpdate;
-    }
-    register(events);
-  });
+    onMount(() => {
+        if (!Object.hasOwn(events, getStandartUpdateEventName())) {
+            events[getStandartUpdateEventName()] = onUpdate;
+        }
+        register(events);
+    });
 </script>
 
-
-<article id="{getCompId()}" class="media">
-  <figure class="media-left">
-    <p class="image is-32x32">
-      <img src={image} alt="{username}"/>
-    </p>
-  </figure>
-  <div class="media-content">
-    <div class="content">
-      <p>
-        <strong>{username}</strong>
-        <small>@</small>
-        <strong>{role}</strong>
-      </p>
+<article id={getCompId()} class="media">
+    <figure class="media-left">
+        <p class="image is-32x32">
+            <img src={image} alt={username} />
+        </p>
+    </figure>
+    <div class="media-content">
+        <div class="content">
+            <p>
+                <strong>{username}</strong>
+                <small>@</small>
+                <strong>{role}</strong>
+            </p>
+        </div>
     </div>
-  </div>
 </article>

package/src/frame/base.js

@@ -1,153 +1,152 @@
-import EventEmitter from 'wolfy87-eventemitter';
-import notPath from 'not-path';
+import EventEmitter from "wolfy87-eventemitter";
+import notPath from "not-path";
 
-import notCommon from './common.js';
+import notCommon from "./common.js";
 
-const META_METHOD_INIT = Symbol('init'),
-  META_DATA = Symbol('data'),
-  META_WORKING = Symbol('working'),
-  META_OPTIONS = Symbol('options');
+const META_METHOD_INIT = Symbol("init"),
+    META_DATA = Symbol("data"),
+    META_WORKING = Symbol("working"),
+    META_OPTIONS = Symbol("options");
 
 export default class notBase extends EventEmitter {
-  constructor(input) {
-    super();
-    this[META_DATA] = {};
-    this[META_WORKING] = {};
-    this[META_OPTIONS] = {};
-    this[META_METHOD_INIT](input);
-    return this;
-  }
-
-  [META_METHOD_INIT](input) {
-    if (!input) {
-      input = {};
+    constructor(input) {
+        super();
+        this[META_DATA] = {};
+        this[META_WORKING] = {};
+        this[META_OPTIONS] = {};
+        this[META_METHOD_INIT](input);
+        return this;
     }
 
-    if (Object.prototype.hasOwnProperty.call(input, 'data')) {
-      this.setData(input.data);
-    }
+    [META_METHOD_INIT](input) {
+        if (!input) {
+            input = {};
+        }
 
-    if (Object.prototype.hasOwnProperty.call(input, 'working')) {
-      this.setWorking(input.working);
-    }
+        if (Object.hasOwn(input, "data")) {
+            this.setData(input.data);
+        }
 
-    if (Object.prototype.hasOwnProperty.call(input,'options')) {
-      this.setOptions(input.options);
-    }
+        if (Object.hasOwn(input, "working")) {
+            this.setWorking(input.working);
+        }
 
-    this.log = notCommon.genLogMsg(this.getWorking('name'));
-    this.info = this.log;
-    this.debug = notCommon.genLogDebug(this.getWorking('name'));
-    this.error = notCommon.genLogError(this.getWorking('name'));
-  }
-
-  setCommon(what, args) {
-    switch (args.length) {
-    case 1:
-    {
-      /* set collection */
-      what = args[0];
-      break;
-    }
-    case 2:
-    {
-      /* set collection element */
-      notPath.set(args[0] /* path */ , what /* collection */ , undefined /* helpers */ , args[1] /* value */ );
-      break;
-    }
-    }
-    return this;
-  }
-  getCommon(what, args) {
-    switch (args.length) {
-    /* if we want get data by path */
-    case 1:
-    {
-      return notPath.get(args[0], what);
-    }
-    /* if we want get data by path with default value */
-    case 2:
-    {
-      let res = notPath.get(args[0], what);
-      if (res === undefined) {
-        /* no data, return default value */
-        return args[1];
-      } else {
-        /* data, return it */
-        return res;
-      }
+        if (Object.hasOwn(input, "options")) {
+            this.setOptions(input.options);
+        }
+
+        this.log = notCommon.genLogMsg(this.getWorking("name"));
+        this.info = this.log;
+        this.debug = notCommon.genLogDebug(this.getWorking("name"));
+        this.error = notCommon.genLogError(this.getWorking("name"));
     }
-    /* return full collection */
-    default:
-    {
-      return what;
+
+    setCommon(what, args) {
+        switch (args.length) {
+            case 1: {
+                /* set collection */
+                what = args[0];
+                break;
+            }
+            case 2: {
+                /* set collection element */
+                notPath.set(
+                    args[0] /* path */,
+                    what /* collection */,
+                    undefined /* helpers */,
+                    args[1] /* value */
+                );
+                break;
+            }
+        }
+        return this;
     }
+    getCommon(what, args) {
+        switch (args.length) {
+            /* if we want get data by path */
+            case 1: {
+                return notPath.get(args[0], what);
+            }
+            /* if we want get data by path with default value */
+            case 2: {
+                let res = notPath.get(args[0], what);
+                if (res === undefined) {
+                    /* no data, return default value */
+                    return args[1];
+                } else {
+                    /* data, return it */
+                    return res;
+                }
+            }
+            /* return full collection */
+            default: {
+                return what;
+            }
+        }
     }
-  }
 
-  /*
+    /*
     CORE OBJECT
       DATA - information
       OPTIONS - how to work
       WORKING - temporarily generated in proccess
   */
 
-  setData() {
-    if (arguments.length === 1) {
-      this[META_DATA] = arguments[0];
-    } else {
-      this.setCommon(this.getData(), arguments);
+    setData() {
+        if (arguments.length === 1) {
+            this[META_DATA] = arguments[0];
+        } else {
+            this.setCommon(this.getData(), arguments);
+        }
+        this.emit("change");
+        return this;
     }
-    this.emit('change');
-    return this;
-  }
-
-  getData() {
-    return this.getCommon(this[META_DATA], arguments);
-  }
-
-  setOptions() {
-    if (arguments.length === 1) {
-      this[META_OPTIONS] = arguments[0];
-    } else {
-      this.setCommon(this.getOptions(), arguments);
+
+    getData() {
+        return this.getCommon(this[META_DATA], arguments);
+    }
+
+    setOptions() {
+        if (arguments.length === 1) {
+            this[META_OPTIONS] = arguments[0];
+        } else {
+            this.setCommon(this.getOptions(), arguments);
+        }
+        return this;
     }
-    return this;
-  }
-
-  getOptions() {
-    return this.getCommon(this[META_OPTIONS], arguments);
-  }
-
-  setWorking() {
-    if (arguments.length === 1) {
-      this[META_WORKING] = arguments[0];
-    } else {
-      this.setCommon(this.getWorking(), arguments);
+
+    getOptions() {
+        return this.getCommon(this[META_OPTIONS], arguments);
     }
-    return this;
-  }
 
-  getWorking() {
-    return this.getCommon(this[META_WORKING], arguments);
-  }
+    setWorking() {
+        if (arguments.length === 1) {
+            this[META_WORKING] = arguments[0];
+        } else {
+            this.setCommon(this.getWorking(), arguments);
+        }
+        return this;
+    }
 
-  report(e) {
-    if (notCommon.report) {
-      notCommon.report(e);
+    getWorking() {
+        return this.getCommon(this[META_WORKING], arguments);
     }
-  }
 
-  getApp(){
-    return notCommon.getApp();
-  }
+    report(e) {
+        if (notCommon.report) {
+            notCommon.report(e);
+        }
+    }
 
-  destroy(){
-    this.removeEvent();
-    this.setOptions(null);
-    this.setWorking(null);
-    this.setData(null);
-    this.emit('destroy');
-  }
+    getApp() {
+        return notCommon.getApp();
+    }
 
+    destroy() {
+        this.removeEvent();
+        this.setOptions(null);
+        this.setWorking(null);
+        this.setData(null);
+        this.emit("destroy");
+    }
 }

package/src/frame/common.js

@@ -158,8 +158,7 @@ class notCommon {
     static isError(e) {
         return (
             e instanceof Error ||
-            (Object.prototype.hasOwnProperty.call(e, "status") &&
-                e.status === "error")
+            (Object.hasOwn(e, "status") && e.status === "error")
         );
     }
 
@@ -195,7 +194,7 @@ class notCommon {
      *  @return {boolean}          if object contains field with name
      **/
     static objHas(obj, name) {
-        return Object.prototype.hasOwnProperty.call(obj, name);
+        return Object.hasOwn(obj, name);
     }
 
     /**
@@ -575,7 +574,7 @@ class notCommon {
                 continue;
             }
             if (typeof notCommon.get(`absorb.${prop}`) === "function") {
-                if (!Object.prototype.hasOwnProperty.call(targets, prop)) {
+                if (!Object.hasOwn(targets, prop)) {
                     targets[prop] = {};
                     notCommon.log(
                         `WARNING: no accamulator object provided for '${prop}' collection`
@@ -583,18 +582,13 @@ class notCommon {
                 }
                 notCommon.get(`absorb.${prop}`)(targets[prop], mod[prop]);
             } else if (prop.indexOf("nc") === 0) {
-                if (
-                    !Object.prototype.hasOwnProperty.call(
-                        defaultConf,
-                        "controllers"
-                    )
-                ) {
+                if (!Object.hasOwn(defaultConf, "controllers")) {
                     defaultConf.controllers = {};
                 }
                 defaultConf.controllers[prop] = mod[prop];
             } else {
                 //in case of some other stuff presented, isolating it in special var
-                if (!Object.prototype.hasOwnProperty.call(window, "notEnv")) {
+                if (!Object.hasOwn(window, "notEnv")) {
                     // @ts-ignore
                     window.notEnv = {};
                 }
@@ -606,7 +600,7 @@ class notCommon {
     }
 
     static defineIfNotExists(obj, key, defaultValue) {
-        if (!Object.prototype.hasOwnProperty.call(obj, key)) {
+        if (!Object.hasOwn(obj, key)) {
             obj[key] = defaultValue;
         }
     }
@@ -618,16 +612,16 @@ class notCommon {
     }
 
     static get(key) {
-        return Object.prototype.hasOwnProperty.call(notCommon.registry, key)
+        return Object.hasOwn(notCommon.registry, key)
             ? notCommon.registry[key]
             : null;
     }
 
-    static moveItem(array, old_index, new_index) {        
-        const inRange = num => num < array.length && num > -1;
-        if(inRange(new_index)&&inRange(old_index)){
+    static moveItem(array, old_index, new_index) {
+        const inRange = (num) => num < array.length && num > -1;
+        if (inRange(new_index) && inRange(old_index)) {
             array.splice(new_index, 0, array.splice(old_index, 1)[0]);
-        }        
+        }
     }
 
     static stripProxy(obj) {
@@ -639,7 +633,7 @@ class notCommon {
                     obj = Object.assign({}, obj);
                 }
                 for (let t in obj) {
-                    if (Object.prototype.hasOwnProperty.call(obj, t)) {
+                    if (Object.hasOwn(obj, t)) {
                         obj[t] = notCommon.stripProxy(obj[t]);
                     }
                 }
@@ -712,7 +706,7 @@ class notCommon {
 function absorbServices(target, src) {
     if (target) {
         for (let serv in src) {
-            if (Object.prototype.hasOwnProperty.call(target, serv)) {
+            if (Object.hasOwn(target, serv)) {
                 notCommon.logError(`services property duplication ${serv}`);
             }
             target[serv] = src[serv];
@@ -721,7 +715,7 @@ function absorbServices(target, src) {
 }
 
 function extendWSClient(wcs, wscName, wscOptions) {
-    if (!Object.prototype.hasOwnProperty.call(wcs, wscName)) {
+    if (!Object.hasOwn(wcs, wscName)) {
         wcs[wscName] = {
             connection: {},
             router: {
@@ -731,15 +725,10 @@ function extendWSClient(wcs, wscName, wscOptions) {
         };
     }
     let target = wcs[wscName];
-    if (Object.prototype.hasOwnProperty.call(wscOptions, "router")) {
-        if (Object.prototype.hasOwnProperty.call(wscOptions.router, "routes")) {
+    if (Object.hasOwn(wscOptions, "router")) {
+        if (Object.hasOwn(wscOptions.router, "routes")) {
             for (let routeType in wscOptions.router.routes) {
-                if (
-                    !Object.prototype.hasOwnProperty.call(
-                        target.router.routes,
-                        routeType
-                    )
-                ) {
+                if (!Object.hasOwn(target.router.routes, routeType)) {
                     target.router.routes[routeType] = {};
                 }
                 Object.assign(target.router.routes[routeType], {
@@ -748,14 +737,14 @@ function extendWSClient(wcs, wscName, wscOptions) {
             }
         }
     }
-    if (Object.prototype.hasOwnProperty.call(wscOptions, "messenger")) {
+    if (Object.hasOwn(wscOptions, "messenger")) {
         Object.assign(target.messenger, { ...wscOptions.messenger });
     }
-    if (Object.prototype.hasOwnProperty.call(wscOptions, "connection")) {
+    if (Object.hasOwn(wscOptions, "connection")) {
         Object.assign(target.connection, { ...wscOptions.connection });
     }
     for (let t of ["name", "getToken", "logger", "identity", "credentials"]) {
-        if (Object.prototype.hasOwnProperty.call(wscOptions, t)) {
+        if (Object.hasOwn(wscOptions, t)) {
             target[t] = wscOptions[t];
         }
     }
@@ -772,7 +761,7 @@ function absorbWSC(target, src) {
 function absorbUIs(target, src) {
     if (target) {
         for (let ui in src) {
-            if (Object.prototype.hasOwnProperty.call(target, ui)) {
+            if (Object.hasOwn(target, ui)) {
                 notCommon.logError(`uis property duplication ${ui}`);
             }
             target[ui] = src[ui];
@@ -783,7 +772,7 @@ function absorbUIs(target, src) {
 function absorbFields(target, src) {
     if (target) {
         for (let ui in src) {
-            if (Object.prototype.hasOwnProperty.call(target, ui)) {
+            if (Object.hasOwn(target, ui)) {
                 notCommon.logError(`fields property duplication ${ui}`);
             }
             target[ui] = src[ui];