native-document 1.0.69 → 1.0.72

package/src/router/RouterComponent.js

@@ -1,3 +1,5 @@
+import Validator from "../core/utils/validator";
+
 /**
  *
  * @param {Router} router
@@ -6,15 +8,24 @@
 export function RouterComponent(router, container) {
 
     const $cache = new Map();
+    let $lastNodeInserted  = null;
 
     const updateContainer = function(node, route) {
         container.innerHTML = '';
+        let nodeToInsert = node;
         const layout = route.layout();
+        if(Validator.isNDElement(node)) {
+            nodeToInsert = node.node();
+        }
         if(layout) {
-            container.appendChild(layout(node));
+            container.appendChild(layout(nodeToInsert));
             return;
         }
-        container.appendChild(node);
+        if(Validator.isAnchor($lastNodeInserted)) {
+            $lastNodeInserted.remove();
+        }
+        container.appendChild(nodeToInsert);
+        $lastNodeInserted = node;
     };
 
     const handleCurrentRouterState = function(state) {

package/src/router/link.js

@@ -1,7 +1,7 @@
-import Validator from "../utils/validator.js";
+import Validator from "../core/utils/validator.js";
 import {Link as NativeLink} from "../../elements.js";
 import Router, {DEFAULT_ROUTER_NAME} from "./Router.js";
-import RouterError from "../errors/RouterError.js";
+import RouterError from "../core/errors/RouterError.js";
 
 
 export function Link(options, children){

package/src/router/modes/HistoryRouter.js

@@ -1,5 +1,5 @@
-import RouterError from '../../errors/RouterError';
-import DebugManager from "../../utils/debug-manager.js";
+import RouterError from '../../core/errors/RouterError';
+import DebugManager from "../../core/utils/debug-manager.js";
 
 export default function HistoryRouter() {
 

package/types/filters/dates.d.ts

@@ -0,0 +1,43 @@
+import { ObservableItem } from '../observable';
+import { FilterResult } from './types';
+
+export type DateValue = Date | string | number | ObservableItem<Date | string | number>;
+
+export function toDate(value: Date | string | number): Date;
+
+export function isSameDay(date1: Date | string | number, date2: Date | string | number): boolean;
+
+export function getSecondsOfDay(date: Date | string | number): number;
+
+export function dateEquals(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function dateBefore(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function dateAfter(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function dateBetween(
+    startObservableOrValue: DateValue,
+    endObservableOrValue: DateValue
+): FilterResult<DateValue>;
+
+export function timeEquals(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function timeAfter(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function timeBefore(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function timeBetween(
+    startObservableOrValue: DateValue,
+    endObservableOrValue: DateValue
+): FilterResult<DateValue>;
+
+export function dateTimeEquals(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function dateTimeAfter(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function dateTimeBefore(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function dateTimeBetween(
+    startObservableOrValue: DateValue,
+    endObservableOrValue: DateValue
+): FilterResult<DateValue>;

package/types/filters/standard.d.ts

@@ -0,0 +1,71 @@
+import { ObservableOrValue, FilterResult } from './types';
+import {ObservableItem} from "../observable";
+
+
+export function equals<T>(
+    observableOrValue: ObservableOrValue<T>
+): FilterResult<T>;
+
+export function notEquals<T>(
+    observableOrValue: ObservableOrValue<T>
+): FilterResult<T>;
+
+export function greaterThan<T extends number | Date>(
+    observableOrValue: ObservableOrValue<T>
+): FilterResult<T>;
+
+export function greaterThanOrEqual<T extends number | Date>(
+    observableOrValue: ObservableOrValue<T>
+): FilterResult<T>;
+
+export function lessThan<T extends number | Date>(
+    observableOrValue: ObservableOrValue<T>
+): FilterResult<T>;
+
+export function lessThanOrEqual<T extends number | Date>(
+    observableOrValue: ObservableOrValue<T>
+): FilterResult<T>;
+
+export function between<T extends number | Date>(
+    minObservableOrValue: ObservableOrValue<T>,
+    maxObservableOrValue: ObservableOrValue<T>
+): FilterResult<T>;
+
+export function inArray<T>(
+    observableOrArray: ObservableOrValue<T[]>
+): FilterResult<T>;
+
+export function notIn<T>(
+    observableOrArray: ObservableOrValue<T[]>
+): FilterResult<T>;
+
+export function isEmpty(
+    observableOrValue?: ObservableOrValue<boolean>
+): FilterResult<ObservableOrValue<boolean>>;
+
+export function isNotEmpty(
+    observableOrValue?: ObservableOrValue<boolean>
+): FilterResult<ObservableOrValue<boolean>>;
+
+export function match(
+    patternObservableOrValue: ObservableOrValue<string | RegExp>,
+    asRegexObservableOrValue?: ObservableOrValue<boolean>,
+    flagsObservableOrValue?: ObservableOrValue<string>
+): FilterResult<string | RegExp>;
+
+export function and<T>(...filters: FilterResult<T>[]): FilterResult<T>;
+
+export function or<T>(...filters: FilterResult<T>[]): FilterResult<T>;
+
+export function not<T>(filter: FilterResult<T>): FilterResult<T>;
+
+
+
+export const gt: typeof greaterThan;
+export const gte: typeof greaterThanOrEqual;
+export const lt: typeof lessThan;
+export const lte: typeof lessThanOrEqual;
+export const eq: typeof equals;
+export const neq: typeof notEquals;
+export const all: typeof and;
+export const any: typeof or;

package/types/filters/strings.d.ts

@@ -0,0 +1,21 @@
+import {FilterResult, ObservableOrValue} from './types';
+
+export function contains(
+    observableOrValue: ObservableOrValue<string>,
+    caseSensitive?: boolean
+): FilterResult<string>;
+
+export function includes(
+    observableOrValue: ObservableOrValue<string>,
+    caseSensitive?: boolean
+): FilterResult<string>;
+
+export function startsWith(
+    observableOrValue: ObservableOrValue<string>,
+    caseSensitive?: boolean
+): FilterResult<string>;
+
+export function endsWith(
+    observableOrValue: ObservableOrValue<string>,
+    caseSensitive?: boolean
+): FilterResult<string>;

package/types/filters/types.d.ts

@@ -0,0 +1,20 @@
+import { ObservableItem } from '../observable';
+
+export interface FilterResult<T = any> {
+    dependencies: ObservableItem | ObservableItem[] | null;
+    callback: (value: T) => boolean;
+}
+
+export type ObservableOrValue<T> = T | ObservableItem<T>;
+
+export type Predicate<T = any> =
+    | T
+    | ((value: T) => boolean)
+    | FilterResult<T>
+    | ObservableItem<T>;
+
+export type PredicateMap<T> = {
+    [K in keyof T]?: Predicate<T[K]>;
+} & {
+    _?: FilterResult<T>;
+};

package/types/forms.d.ts

@@ -1,5 +1,6 @@
 // Form elements type definitions
-import { Attributes, ValidChild, NDElement } from './elements';
+import { Attributes, ValidChild } from './elements';
+import { NDElement} from "./nd-element";
 import {ElementFunction} from "./elements";
 
 // Form Elements

package/types/observable.d.ts

@@ -1,3 +1,5 @@
+import {FilterResult, PredicateMap} from "./filters/types";
+
 export type Unsubscribe = () => void;
 
 // Observable system type definitions
@@ -89,6 +91,10 @@ export interface ObservableArray<T> extends ObservableItem<T[]> {
     at(index: number): T | undefined;
     findIndex(callback: (value: T, index: number, array: T[]) => boolean): number;
     concat(...items: (T | T[])[]): T[];
+
+    where(predicates: PredicateMap<T>): ObservableArray<T>;
+    whereSome<K extends keyof T>(fields: K[], filter: FilterResult<T[K]>): ObservableArray<T>;
+    whereEvery<K extends keyof T>(fields: K[], filter: FilterResult<T[K]>): ObservableArray<T>;
 }
 
 export type ObservableProxy<T extends Record<string, any>> = {

package/types/validator.ts

@@ -1,5 +1,6 @@
 import {ObservableChecker, ObservableItem, ObservableProxy} from "./observable";
-import { NDElement, ValidChild } from "./elements";
+import { ValidChild } from "./elements";
+import { NDElement } from "./nd-element";
 
 export type ValidChildren = ValidChild | ValidChild[];
 

package/utils.js

@@ -1,6 +1,6 @@
-import NativeFetch from "./src/utils/fetch/NativeFetch";
-import { Service } from "./src/utils/service";
-import * as Filters from "./src/utils/filters/index";
+import NativeFetch from "./src/fetch/NativeFetch";
+import { Service } from "./src/core/utils/service";
+import * as Filters from "./src/core/utils/filters/index";
 
 
 export {

package/src/wrappers/NdPrototype.js

@@ -1,71 +0,0 @@
-import { NDElement } from "./NDElement";
-
-const property = {
-    configurable: true,
-    get() {
-        return  new NDElement(this);
-    }
-};
-
-Object.defineProperty(HTMLElement.prototype, 'nd', property);
-
-Object.defineProperty(DocumentFragment.prototype, 'nd', property);
-Object.defineProperty(NDElement.prototype, 'nd', {
-    configurable: true,
-    get: function() {
-        return this;
-    }
-});
-
-const classListMethods = {
-    getClasses() {
-        return this.$element.className?.split(' ').filter(Boolean);
-    },
-    add(value) {
-        const classes = this.getClasses();
-        if(classes.indexOf(value) >= 0) {
-            return;
-        }
-        classes.push(value);
-        this.$element.className = classes.join(' ');
-    },
-    remove(value) {
-        const classes = this.getClasses();
-        const index = classes.indexOf(value);
-        if(index < 0) {
-            return;
-        }
-        classes.splice(index, 1);
-        this.$element.className = classes.join(' ');
-    },
-    toggle(value, force = undefined) {
-        const classes = this.getClasses();
-        const index = classes.indexOf(value);
-        if(index >= 0) {
-            if(force === true) {
-                return;
-            }
-            classes.splice(index, 1);
-        }
-        else {
-            if(force === false) {
-                return;
-            }
-            classes.push(value);
-        }
-        this.$element.className = classes.join(' ');
-    },
-    contains(value) {
-        return this.getClasses().indexOf(value) >= 0;
-    }
-}
-
-Object.defineProperty(HTMLElement.prototype, 'classes', {
-    configurable: true,
-    get() {
-        return {
-            $element: this,
-            ...classListMethods
-        };
-    }
-});