native-document 1.0.258 → 1.0.261

package/index.js

@@ -8,8 +8,8 @@ export { SingletonView, useSingleton } from './src/core/wrappers/SingletonView';
 export { default as PluginsManager } from './src/core/utils/plugins-manager';
 export { default as Validator } from './src/core/utils/validator';
 
-export { Formatters } from "./src/core/utils/formatters";
-export {default as ShortcutManager} from "./src/core/utils/shortcut-manager";
+export { Formatters } from './src/core/utils/formatters';
+export {default as ShortcutManager} from './src/core/utils/shortcut-manager';
 
 export * from './src/core/utils/property-accumulator';
 export * from './src/core/utils/args-types';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "native-document",
-  "version": "1.0.258",
+  "version": "1.0.261",
   "description": "A reactive JavaScript framework that preserves native DOM simplicity without sacrificing modern features",
   "author": "AfroCodeur <https://github.com/afrocodeur>",
   "license": "MIT",

package/src/core/data/ObservableArray.js

@@ -6,7 +6,7 @@ import NativeDocumentError from '../errors/NativeDocumentError.js';
 import {nextTick} from '../utils/helpers';
 
 export const mutationMethods = ['push', 'pop', 'shift', 'unshift', 'reverse', 'sort', 'splice'];
-export const noMutationMethods = ['map', 'forEach', 'filter', 'reduce', 'some', 'every', 'find', 'findIndex', 'concat', 'includes', 'indexOf'];
+export const noMutationMethods = ['map', 'forEach', 'filter', 'reduce', 'some', 'every', 'find', 'findIndex', 'concat', 'includes', 'indexOf', 'at', 'lastIndexOf', 'findLastIndex'];
 
 const toObservable = (item) => item?.__$Observable ? item : ObservableArray.auto(item);
 
@@ -578,4 +578,12 @@ ObservableArray.prototype.fnClear = function () {
 //     return result;
 // };
 
+ObservableArray.prototype.first = function () {
+    return this.$currentValue[0];
+};
+
+ObservableArray.prototype.last = function () {
+    return this.$currentValue.at(-1);
+};
+
 export default ObservableArray;

package/src/core/data/ObservableQuery.js

@@ -123,6 +123,10 @@ ObservableQuery.prototype.map = function(fn) {
 
 ObservableQuery.prototype.set = function(dataset) {
     this.$currentResultData.forEach((element) => {
+        if(typeof element.set === 'function') {
+            element.set(dataset);
+            return;
+        }
         for(const key in dataset) {
             const prop = element[key];
             const value = dataset[key];

package/src/core/utils/helpers.js

@@ -141,4 +141,21 @@ export const deepClone = (value, onObservableFound) => {
         }
     }
     return cloned;
+};
+
+
+export const lock = (fn, defaultReturn) => {
+    let isLocked = false;
+
+    return async (...args) => {
+        if(isLocked) {
+            return typeof defaultReturn === 'function' ? defaultReturn() : defaultReturn;
+        }
+        isLocked = true;
+        try {
+            return await fn(...args);
+        } finally {
+            isLocked = false;
+        }
+    };
 };

package/types/helpers.d.ts

@@ -0,0 +1,7 @@
+
+
+
+export declare const lock: <TArgs extends any[], TResult, TDefault = undefined>(
+    fn: (...args: TArgs) => Promise<TResult> | TResult,
+    defaultReturn?: TDefault | (() => TDefault)
+) => (...args: TArgs) => Promise<TResult | TDefault>;

package/types/observable.d.ts

@@ -217,9 +217,14 @@ export interface ObservableArray<T> extends ObservableItem<T[]> {
     find(callback: (value: T, index: number, array: T[]) => boolean): T | undefined;
     at(index: number): T | undefined;
     findIndex(callback: (value: T, index: number, array: T[]) => boolean): number;
+    findLastIndex(callback: (value: T, index: number, array: T[]) => boolean): number;
     concat(...items: (T | T[])[]): T[];
     indexOf(item: T): number;
+    lastIndexOf(item: T): number;
     includes(item: T): boolean;
+    at(index: number): T | undefined;
+    first(): T | undefined;
+    last(): T | undefined;
 
     where(predicates: PredicateMap<T> | ((item: T) => boolean)): ObservableArray<T>;
     whereSome<K extends keyof T>(fields: K[], filter: FilterResult<T[K]>): ObservableArray<T>;

package/utils.d.ts

@@ -2,4 +2,5 @@
 export * from './types/native-fetch';
 export * from './types/service';
 export * as filters from './types/filters/index';
-export * from './types/localStorage'
+export * from './types/localStorage'
+export * from './types/helpers';

package/utils.js

@@ -4,6 +4,8 @@ import * as filters from './src/core/utils/filters/index';
 import {classPropertyAccumulator, cssPropertyAccumulator} from './src/core/utils/property-accumulator';
 import {LocalStorage} from './src/core/utils/localstorage';
 
+export * from './src/core/utils/helpers';
+
 const Service = Cache;
 
 export {