selectic 3.0.10 → 3.0.11

package/dist/selectic.common.js

@@ -41,7 +41,8 @@ styleInject(css_248z);
  * @param refs internal reference to object to avoid cyclic references
  * @returns a copy of obj
  */
-function deepClone(obj, refs = new WeakMap()) {
+function deepClone(origObject, ignoreAttributes = [], refs = new WeakMap()) {
+    const obj = vue.unref(origObject);
     /* For circular references */
     if (refs.has(obj)) {
         return refs.get(obj);
@@ -54,7 +55,7 @@ function deepClone(obj, refs = new WeakMap()) {
             const ref = [];
             refs.set(obj, ref);
             obj.forEach((val, idx) => {
-                ref[idx] = deepClone(val, refs);
+                ref[idx] = deepClone(val, ignoreAttributes, refs);
             });
             return ref;
         }
@@ -67,7 +68,11 @@ function deepClone(obj, refs = new WeakMap()) {
         const ref = {};
         refs.set(obj, ref);
         for (const [key, val] of Object.entries(obj)) {
-            ref[key] = deepClone(val, refs);
+            if (ignoreAttributes.includes(key)) {
+                ref[key] = val;
+                continue;
+            }
+            ref[key] = deepClone(val, ignoreAttributes, refs);
         }
         return ref;
     }
@@ -684,7 +689,7 @@ class SelecticStore {
     }
     /* This method is for the computed property listOptions */
     getListOptions() {
-        const options = deepClone(this.props.options);
+        const options = deepClone(this.props.options, ['data']);
         const listOptions = [];
         if (!Array.isArray(options)) {
             return listOptions;
@@ -721,7 +726,7 @@ class SelecticStore {
     }
     /* This method is for the computed property elementOptions */
     getElementOptions() {
-        const options = deepClone(this.props.childOptions);
+        const options = deepClone(this.props.childOptions, ['data']);
         const childOptions = [];
         if (!Array.isArray(options) || options.length === 0) {
             return childOptions;

package/dist/selectic.esm.js

@@ -1,5 +1,5 @@
 import { Prop, Watch, Component, Vue, h, Emit } from 'vtyx';
-import { reactive, computed, unref, watch } from 'vue';
+import { unref, reactive, computed, watch } from 'vue';
 
 function styleInject(css, ref) {
   if ( ref === void 0 ) ref = {};
@@ -37,7 +37,8 @@ styleInject(css_248z);
  * @param refs internal reference to object to avoid cyclic references
  * @returns a copy of obj
  */
-function deepClone(obj, refs = new WeakMap()) {
+function deepClone(origObject, ignoreAttributes = [], refs = new WeakMap()) {
+    const obj = unref(origObject);
     /* For circular references */
     if (refs.has(obj)) {
         return refs.get(obj);
@@ -50,7 +51,7 @@ function deepClone(obj, refs = new WeakMap()) {
             const ref = [];
             refs.set(obj, ref);
             obj.forEach((val, idx) => {
-                ref[idx] = deepClone(val, refs);
+                ref[idx] = deepClone(val, ignoreAttributes, refs);
             });
             return ref;
         }
@@ -63,7 +64,11 @@ function deepClone(obj, refs = new WeakMap()) {
         const ref = {};
         refs.set(obj, ref);
         for (const [key, val] of Object.entries(obj)) {
-            ref[key] = deepClone(val, refs);
+            if (ignoreAttributes.includes(key)) {
+                ref[key] = val;
+                continue;
+            }
+            ref[key] = deepClone(val, ignoreAttributes, refs);
         }
         return ref;
     }
@@ -680,7 +685,7 @@ class SelecticStore {
     }
     /* This method is for the computed property listOptions */
     getListOptions() {
-        const options = deepClone(this.props.options);
+        const options = deepClone(this.props.options, ['data']);
         const listOptions = [];
         if (!Array.isArray(options)) {
             return listOptions;
@@ -717,7 +722,7 @@ class SelecticStore {
     }
     /* This method is for the computed property elementOptions */
     getElementOptions() {
-        const options = deepClone(this.props.childOptions);
+        const options = deepClone(this.props.childOptions, ['data']);
         const childOptions = [];
         if (!Array.isArray(options) || options.length === 0) {
             return childOptions;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "selectic",
-    "version": "3.0.10",
+    "version": "3.0.11",
     "description": "Smart Select for VueJS 3.x",
     "main": "dist/selectic.common.js",
     "module": "dist/selectic.esm.js",

package/rollup.config.js

@@ -30,5 +30,12 @@ export default [{
         'vtyx',
     ],
     context: 'this',
+}, {
+    input: 'lib/tools.js',
+    output: [{
+        file: 'test/dist/tools.js',
+        exports: 'named',
+        format: 'cjs',
+    }],
+    context: 'this',
 }];
-

package/src/Store.tsx

@@ -1060,7 +1060,7 @@ export default class SelecticStore {
 
     /* This method is for the computed property listOptions */
     private getListOptions(): OptionValue[] {
-        const options = deepClone(this.props.options);
+        const options = deepClone(this.props.options, ['data']);
         const listOptions: OptionValue[] = [];
 
         if (!Array.isArray(options)) {
@@ -1106,7 +1106,7 @@ export default class SelecticStore {
 
     /* This method is for the computed property elementOptions */
     private getElementOptions(): OptionValue[] {
-        const options = deepClone(this.props.childOptions);
+        const options = deepClone(this.props.childOptions, ['data']);
         const childOptions: OptionValue[] = [];
 
         if (!Array.isArray(options) || options.length === 0) {

package/src/tools.ts

@@ -1,3 +1,4 @@
+import { unref } from 'vue';
 
 /**
  * Clone the object and its inner properties.
@@ -5,7 +6,9 @@
  * @param refs internal reference to object to avoid cyclic references
  * @returns a copy of obj
  */
-export function deepClone<T = any>(obj: T, refs: WeakMap<any, any> = new WeakMap()): T {
+export function deepClone<T = any>(origObject: T, ignoreAttributes: string[] = [], refs: WeakMap<any, any> = new WeakMap()): T {
+    const obj = unref(origObject);
+
     /* For circular references */
     if (refs.has(obj)) {
         return refs.get(obj);
@@ -20,7 +23,7 @@ export function deepClone<T = any>(obj: T, refs: WeakMap<any, any> = new WeakMap
             const ref: any[] = [];
             refs.set(obj, ref);
             obj.forEach((val, idx) => {
-                ref[idx] = deepClone(val, refs);
+                ref[idx] = deepClone(val, ignoreAttributes, refs);
             });
             return ref as unknown as T;
         }
@@ -35,7 +38,12 @@ export function deepClone<T = any>(obj: T, refs: WeakMap<any, any> = new WeakMap
         const ref: any = {};
         refs.set(obj, ref);
         for (const [key, val] of Object.entries(obj)) {
-            ref[key] = deepClone(val, refs);
+            if (ignoreAttributes.includes(key)) {
+                ref[key] = val;
+                continue;
+            }
+
+            ref[key] = deepClone(val, ignoreAttributes, refs);
         }
         return ref as unknown as T;
     }
@@ -44,7 +52,6 @@ export function deepClone<T = any>(obj: T, refs: WeakMap<any, any> = new WeakMap
     return obj;
 }
 
-
 /**
  * Escape search string to consider regexp special characters as they
  * are and not like special characters.

package/test/Store/Store_creation.spec.js

@@ -1,16 +1,3 @@
-/**************************************************************************/
-/*                                                                        */
-/*  Copyright (C) INTERSEC SA                                             */
-/*                                                                        */
-/*  Should you receive a copy of this source code, you must check you     */
-/*  have a proper, written authorization of INTERSEC to hold it. If you   */
-/*  don't have such an authorization, you must DELETE all source code     */
-/*  files in your possession, and inform INTERSEC of the fact you obtain  */
-/*  these files. Should you not comply to these terms, you can be         */
-/*  prosecuted in the extent permitted by applicable law.                 */
-/*                                                                        */
-/**************************************************************************/
-
 const _ = require('../tools.js');
 const {
     getInitialState,

package/test/Store/commit.spec.js

@@ -1,16 +1,3 @@
-/**************************************************************************/
-/*                                                                        */
-/*  Copyright (C) INTERSEC SA                                             */
-/*                                                                        */
-/*  Should you receive a copy of this source code, you must check you     */
-/*  have a proper, written authorization of INTERSEC to hold it. If you   */
-/*  don't have such an authorization, you must DELETE all source code     */
-/*  files in your possession, and inform INTERSEC of the fact you obtain  */
-/*  these files. Should you not comply to these terms, you can be         */
-/*  prosecuted in the extent permitted by applicable law.                 */
-/*                                                                        */
-/**************************************************************************/
-
 const _ = require('../tools.js');
 const {
     getInitialState,

package/test/Store/getItem.spec.js

@@ -1,16 +1,3 @@
-/**************************************************************************/
-/*                                                                        */
-/*  Copyright (C) INTERSEC SA                                             */
-/*                                                                        */
-/*  Should you receive a copy of this source code, you must check you     */
-/*  have a proper, written authorization of INTERSEC to hold it. If you   */
-/*  don't have such an authorization, you must DELETE all source code     */
-/*  files in your possession, and inform INTERSEC of the fact you obtain  */
-/*  these files. Should you not comply to these terms, you can be         */
-/*  prosecuted in the extent permitted by applicable law.                 */
-/*                                                                        */
-/**************************************************************************/
-
 const _ = require('../tools.js');
 const {
     buildFetchCb,

package/test/Store/getItems.spec.js

@@ -1,16 +1,3 @@
-/**************************************************************************/
-/*                                                                        */
-/*  Copyright (C) INTERSEC SA                                             */
-/*                                                                        */
-/*  Should you receive a copy of this source code, you must check you     */
-/*  have a proper, written authorization of INTERSEC to hold it. If you   */
-/*  don't have such an authorization, you must DELETE all source code     */
-/*  files in your possession, and inform INTERSEC of the fact you obtain  */
-/*  these files. Should you not comply to these terms, you can be         */
-/*  prosecuted in the extent permitted by applicable law.                 */
-/*                                                                        */
-/**************************************************************************/
-
 const _ = require('../tools.js');
 const {
     getOptions,

package/test/Store/selectItem.spec.js

@@ -1,16 +1,3 @@
-/**************************************************************************/
-/*                                                                        */
-/*  Copyright (C) INTERSEC SA                                             */
-/*                                                                        */
-/*  Should you receive a copy of this source code, you must check you     */
-/*  have a proper, written authorization of INTERSEC to hold it. If you   */
-/*  don't have such an authorization, you must DELETE all source code     */
-/*  files in your possession, and inform INTERSEC of the fact you obtain  */
-/*  these files. Should you not comply to these terms, you can be         */
-/*  prosecuted in the extent permitted by applicable law.                 */
-/*                                                                        */
-/**************************************************************************/
-
 const _ = require('../tools.js');
 const {
     getOptions,

package/test/Store/toggleSelectAll.spec.js

@@ -1,16 +1,3 @@
-/**************************************************************************/
-/*                                                                        */
-/*  Copyright (C) INTERSEC SA                                             */
-/*                                                                        */
-/*  Should you receive a copy of this source code, you must check you     */
-/*  have a proper, written authorization of INTERSEC to hold it. If you   */
-/*  don't have such an authorization, you must DELETE all source code     */
-/*  files in your possession, and inform INTERSEC of the fact you obtain  */
-/*  these files. Should you not comply to these terms, you can be         */
-/*  prosecuted in the extent permitted by applicable law.                 */
-/*                                                                        */
-/**************************************************************************/
-
 const _ = require('../tools.js');
 const {
     getOptions,

package/test/Tools/tools.spec.js

@@ -0,0 +1,404 @@
+const tape = require('tape');
+const toolFile = require('../dist/tools.js');
+
+const {
+    assignObject,
+    convertToRegExp,
+    deepClone,
+} = toolFile;
+
+tape.test('assignObject()', (st) => {
+    st.test('behaves like Object.assign', (tst) => {
+        const deep1 = {
+            dp: 1,
+        };
+        const deep2 = {
+            dp: 2,
+            other: 'value',
+        };
+        const obj1 = {
+            a: 1,
+            b: 2,
+            c: false,
+            deep: deep1,
+        };
+        const obj2 = {
+            a: 3,
+            c: true,
+            d: false,
+            deep: deep2,
+            other: {
+                attr: 'str',
+            },
+        };
+
+        const result = assignObject(obj1, obj2);
+
+        tst.is(result, obj1, 'should modify first argument');
+        tst.deepEqual(result, {
+            a: 3,
+            b: 2,
+            c: true,
+            d: false,
+            deep: {
+                dp: 2,
+                other: 'value',
+            },
+            other: {
+                attr: 'str',
+            },
+        }, 'should merge all attributes');
+        tst.is(result.deep, deep2, 'should keep references');
+        tst.deepEqual(obj2, {
+            a: 3,
+            c: true,
+            d: false,
+            deep: deep2,
+            other: {
+                attr: 'str',
+            },
+        }, 'should not change second argument');
+        tst.end();
+    });
+
+    st.test('accept multiple arguments', (tst) => {
+        const obj1 = {
+            a: 1,
+            b: 2,
+        };
+        const obj2 = {
+            a: 2,
+            c: 3,
+        };
+        const obj3 = {
+            a: 3,
+            d: 4,
+        };
+        const obj4 = {
+            a: 4,
+            e: 5,
+        };
+
+        const result = assignObject(obj1, obj2, obj3, obj4);
+
+        tst.is(result, obj1, 'should modify first argument');
+        tst.deepEqual(result, {
+            a: 4,
+            b: 2,
+            c: 3,
+            d: 4,
+            e: 5,
+        }, 'should merge all attributes');
+        tst.deepEqual(obj2, {
+            a: 2,
+            c: 3,
+        }, 'should not change second argument');
+        tst.deepEqual(obj3, {
+            a: 3,
+            d: 4,
+        }, 'should not change third argument');
+        tst.deepEqual(obj4, {
+            a: 4,
+            e: 5,
+        }, 'should not change fourth argument');
+        tst.end();
+    });
+
+    st.test('ignores undefined attributes', (tst) => {
+        const obj1 = {
+            a: 1, // modified by all
+            b: 2, // not modified by all (undefined)
+            c: 3, // obj2: undefined, modified by obj3
+            d: 4, // modified by obj2, obj3: undefined
+            e: 5, // not set by obj2, obj3: undefined
+            f: 6, // not set by all
+        };
+        const obj2 = {
+            a: 'a',
+            b: undefined,
+            c: undefined,
+            d: 'd',
+        };
+        const obj3 = {
+            a: 2,
+            b: undefined,
+            c: 'c',
+            d: undefined,
+            e: undefined,
+        };
+
+        const result = assignObject(obj1, obj2, obj3);
+
+        tst.is(result, obj1, 'should modify first argument');
+        tst.deepEqual(result, {
+            a: 2,
+            b: 2,
+            c: 'c',
+            d: 'd',
+            e: 5,
+            f: 6,
+        }, 'should merge all attributes');
+        tst.deepEqual(obj2, {
+            a: 'a',
+            b: undefined,
+            c: undefined,
+            d: 'd',
+        }, 'should not change second argument');
+        tst.deepEqual(obj3, {
+            a: 2,
+            b: undefined,
+            c: 'c',
+            d: undefined,
+            e: undefined,
+        }, 'should not change third argument');
+        tst.end();
+    });
+});
+
+tape.test('convertToRegExp()', (st) => {
+    st.test('convert wildcard', (tst) => {
+        const str = '*the search*';
+
+        const result = convertToRegExp(str);
+
+        tst.is(result instanceof RegExp, true, 'should create a RegExp');
+
+        const pattern = result.source;
+        const flags = result.flags;
+
+        tst.is(pattern, '.*the search.*', 'should create wildcard sequence');
+        tst.is(flags, 'i', 'should be case insensitive by default');
+
+        tst.end();
+    });
+    st.test('escape special characters', (tst) => {
+        const str = '\\^$.+?(){}[]|';
+
+        const result = convertToRegExp(str);
+
+        tst.is(result instanceof RegExp, true, 'should create a RegExp');
+
+        const pattern = result.source;
+        const flags = result.flags;
+
+        tst.is(pattern, '\\\\\\^\\$\\.\\+\\?\\(\\)\\{\\}\\[\\]\\|', 'should escape special characters');
+        tst.is(flags, 'i', 'should be case insensitive by default');
+
+        tst.end();
+    });
+
+    st.test('allow RegExp flags', (tst) => {
+        const str = 'file*.*';
+
+        const result = convertToRegExp(str, 'gm');
+
+        tst.is(result instanceof RegExp, true, 'should create a RegExp');
+
+        const pattern = result.source;
+        const flags = result.flags;
+
+        tst.is(pattern, 'file.*\\..*', 'should convert special characters');
+        tst.is(flags, 'gm', 'should set flags');
+
+        tst.end();
+    });
+});
+
+tape.test('deepClone()', (st) => {
+    st.test('should copy simple object', (tst) => {
+        const fn = () => {};
+        const objRef = {
+            a: 1,
+            b: 'b',
+            c: false,
+            d: undefined,
+            e: null,
+            f: {},
+            g: fn,
+            spe1: NaN,
+            spe2: Infinity,
+            spe3: '',
+            spe4: [],
+        };
+
+        const result = deepClone(objRef);
+
+        tst.isNot(result, objRef, 'should create a copy');
+        tst.deepEqual(result, objRef, 'should have been similar to original');
+
+        tst.end();
+    });
+
+    st.test('should copy nested object', (tst) => {
+        const fn = () => {};
+        const deep1 = {
+            a: 1,
+            b: 'b',
+            c: false,
+            d: undefined,
+            e: null,
+            f: {},
+            g: fn,
+            spe1: NaN,
+            spe2: Infinity,
+            spe3: '',
+            spe4: [],
+        };
+        const deep2 = {
+            deep: deep1,
+            added: 'a value',
+        };
+        const objRef = {
+            d: deep2,
+        }
+
+        const result = deepClone(objRef);
+
+        tst.isNot(result, objRef, 'should create a copy');
+        tst.deepEqual(result, objRef, 'should have been similar to original');
+        tst.isNot(result.d, deep2, 'should copy nested object');
+        tst.isNot(result.d.deep, deep1, 'should copy deeper nested object');
+
+        tst.end();
+    });
+
+
+    st.test('with arrays', (tst) => {
+        const fn = () => {};
+        const objRef = {
+            a: 1,
+            b: 'b',
+            c: false,
+            d: undefined,
+            e: null,
+            f: {},
+            g: fn,
+            spe1: NaN,
+            spe2: Infinity,
+            spe3: '',
+            spe4: [],
+        };
+        const nestedArray1 = [
+            objRef,
+            { a: 'value' },
+            null,
+            undefined,
+            42,
+            'value',
+        ];
+        const nestedArray2 = [
+            objRef,
+            { a: 'value' },
+            null,
+            undefined,
+            42,
+            'value',
+        ];
+        const arrayRef = [
+            {
+                deep: nestedArray1,
+            },
+            nestedArray2,
+            42, 'value', null, undefined, [[]],
+        ];
+
+        const result = deepClone(arrayRef);
+
+        tst.isNot(result, arrayRef, 'should create a copy');
+        tst.is(Array.isArray(arrayRef), true, 'should create an array');
+        tst.deepEqual(result, arrayRef, 'should have been similar to original');
+        tst.isNot(result[1], nestedArray2, 'should copy nested array');
+        tst.isNot(result[0].deep, nestedArray1, 'should copy deeper nested array');
+        tst.isNot(result[1][0], objRef, 'should copy nested object');
+        tst.isNot(result[0].deep[0], objRef, 'should copy deeper nested object');
+
+        tst.end();
+    });
+
+    st.test('with RegExp', (tst) => {
+        const r1 = /hello?/gi;
+        const r2 = /.* [aA]+?/;
+
+        const result1 = deepClone(r1);
+        const result2 = deepClone({rgx: r2});
+
+        tst.isNot(result1, r1, 'should copy RegExp');
+        tst.is(result1 instanceof RegExp, true, 'should create a RegExp');
+        tst.is(result1.source, 'hello?', 'should copy pattern');
+        tst.is(result1.flags, 'gi', 'should copy flags');
+
+        tst.isNot(result2.rgx, r2, 'should copy the RegExp');
+        tst.is(result2.rgx.source, '.* [aA]+?', 'should copy the attribute pattern');
+        tst.is(result2.rgx.flags, '', 'should copy the attribute flags');
+        tst.end();
+    });
+
+    st.test('with primitives', (tst) => {
+        const result1 = deepClone(1);
+        const result2 = deepClone('a');
+        const result3 = deepClone(false);
+        const result4 = deepClone(null);
+        const result5 = deepClone(undefined);
+
+        tst.is(result1, 1, 'should return number');
+        tst.is(result2, 'a', 'should return string');
+        tst.is(result3, false, 'should return boolean');
+        tst.is(result4, null, 'should return null');
+        tst.is(result5, undefined, 'should return undefined');
+        tst.end();
+    });
+
+    st.test('with circular references', (tst) => {
+        const obj1 = {
+            a: 'a',
+        }
+        const obj2 = {
+            b: 'b',
+        }
+        obj1.child = obj1;
+        obj1.sibling = obj2;
+        obj2.sibling = obj1;
+
+        const ref = [obj1, obj2];
+
+        const result = deepClone(ref);
+
+        tst.isNot(result, ref, 'should create a new object');
+        tst.isNot(result[0], obj1, 'should copy inner objects');
+        tst.is(result[0].child, result[0], 'should keep the circular reference');
+        tst.is(result[1].sibling, result[0], 'should keep similar references');
+        tst.is(result[0].sibling, result[1], 'should keep similar references (2)');
+
+        tst.end();
+    });
+
+    st.test('can ignore some attributes', (tst) => {
+        const noCopy1 = {
+            ref: 1,
+        };
+        const noCopy2 = new Set(['alpha', 'omega']);
+        const noCopy3 = new Map([[1, 'alpha'], [22, 'omega']]);
+        const deep1 = {
+            a: 'alpha',
+            noCopy: noCopy3,
+        };
+        const ref = {
+            id: 'ref',
+            noCopy: noCopy1,
+            nop: noCopy2,
+            not: 42,
+            deep: deep1,
+        };
+
+        const result = deepClone(ref, ['noCopy', 'nothing', 'nop', 'not']);
+
+        tst.isNot(result, ref, 'should create a new object');
+        tst.isNot(result.deep, deep1, 'should create a new object');
+        tst.is(result.noCopy, noCopy1, 'should keep original reference');
+        tst.is(result.nop, noCopy2, 'should keep original reference (2)');
+        tst.is(result.not, 42, 'should keep primitive');
+        tst.is(result.deep.noCopy, noCopy3, 'should keep nested original reference');
+
+        tst.end();
+    });
+});

package/types/tools.d.ts

@@ -4,7 +4,7 @@
  * @param refs internal reference to object to avoid cyclic references
  * @returns a copy of obj
  */
-export declare function deepClone<T = any>(obj: T, refs?: WeakMap<any, any>): T;
+export declare function deepClone<T = any>(origObject: T, ignoreAttributes?: string[], refs?: WeakMap<any, any>): T;
 /**
  * Escape search string to consider regexp special characters as they
  * are and not like special characters.