native-document 1.0.15 → 1.0.16-8.1

package/src/elements/html5-semantics.js

@@ -1,12 +0,0 @@
-import HtmlElementWrapper from "../wrappers/HtmlElementWrapper";
-
-export const Main = HtmlElementWrapper('main');
-export const Section = HtmlElementWrapper('section');
-export const Article = HtmlElementWrapper('article');
-export const Aside = HtmlElementWrapper('aside');
-export const Nav = HtmlElementWrapper('nav');
-export const Figure = HtmlElementWrapper('figure');
-export const FigCaption = HtmlElementWrapper('figcaption');
-
-export const Header = HtmlElementWrapper('header');
-export const Footer = HtmlElementWrapper('footer');

package/src/elements/img.js

@@ -1,45 +0,0 @@
-import HtmlElementWrapper from "../wrappers/HtmlElementWrapper"
-import Validator from "../utils/validator";
-import NativeDocumentError from "../errors/NativeDocumentError";
-
-export const BaseImage = HtmlElementWrapper('img');
-export const Img = function(src, attributes) {
-    return BaseImage({ src, ...attributes });
-};
-
-/**
- *
- * @param {string} src
- * @param {string|null} defaultImage
- * @param {Object} attributes
- * @param {?Function} callback
- * @returns {Image}
- */
-export const AsyncImg = function(src, defaultImage, attributes, callback) {
-    const image = Img(defaultImage || src, attributes);
-    const img = new Image();
-    img.onload = () => {
-        Validator.isFunction(callback) && callback(null, image);
-        image.src = src;
-    };
-    img.onerror = () => {
-        Validator.isFunction(callback) && callback(new NativeDocumentError('Image not found'));
-    };
-    if(Validator.isObservable(src)) {
-        src.subscribe(newSrc => {
-            img.src = newSrc;
-        });
-    }
-    img.src = src;
-    return image;
-};
-
-/**
- *
- * @param {string} src
- * @param {Object} attributes
- * @returns {Image}
- */
-export const LazyImg = function(src, attributes) {
-    return Img(src, { ...attributes, loading: 'lazy' });
-};

package/src/elements/interactive.js

@@ -1,7 +0,0 @@
-import HtmlElementWrapper from "../wrappers/HtmlElementWrapper";
-
-
-export const Details = HtmlElementWrapper('details');
-export const Summary = HtmlElementWrapper('summary');
-export const Dialog = HtmlElementWrapper('dialog');
-export const Menu = HtmlElementWrapper('menu');

package/src/elements/list.js

@@ -1,10 +0,0 @@
-import HtmlElementWrapper from "../wrappers/HtmlElementWrapper";
-
-export const OrderedList = HtmlElementWrapper('ol');
-export const UnorderedList = HtmlElementWrapper('ul');
-export const ListItem = HtmlElementWrapper('li');
-
-export const Li = ListItem;
-export const Ol = OrderedList;
-export const Ul = UnorderedList;
-

package/src/elements/medias.js

@@ -1,8 +0,0 @@
-import HtmlElementWrapper from "../wrappers/HtmlElementWrapper";
-
-export const Audio = HtmlElementWrapper('audio');
-export const Video = HtmlElementWrapper('video');
-export const Source = HtmlElementWrapper('source');
-export const Track = HtmlElementWrapper('track');
-export const Canvas = HtmlElementWrapper('canvas');
-export const Svg = HtmlElementWrapper('svg');

package/src/elements/meta-data.js

@@ -1,9 +0,0 @@
-import HtmlElementWrapper from "../wrappers/HtmlElementWrapper";
-
-export const Time = HtmlElementWrapper('time');
-export const Data = HtmlElementWrapper('data');
-export const Address = HtmlElementWrapper('address');
-export const Kbd = HtmlElementWrapper('kbd');
-export const Samp = HtmlElementWrapper('samp');
-export const Var = HtmlElementWrapper('var');
-export const Wbr = HtmlElementWrapper('wbr');

package/src/elements/table.js

@@ -1,14 +0,0 @@
-import HtmlElementWrapper from "../wrappers/HtmlElementWrapper";
-
-export const Caption = HtmlElementWrapper('caption');
-export const Table = HtmlElementWrapper('table');
-export const THead = HtmlElementWrapper('thead');
-export const TFoot = HtmlElementWrapper('tfoot');
-export const TBody = HtmlElementWrapper('tbody');
-export const Tr = HtmlElementWrapper('tr');
-export const TRow = Tr;
-export const Th = HtmlElementWrapper('th');
-export const THeadCell = Th;
-export const TFootCell = Th;
-export const Td = HtmlElementWrapper('td');
-export const TBodyCell = Td;

package/src/utils/args-types.js

@@ -1,100 +0,0 @@
-import Validator from "./validator";
-import ArgTypesError from "../errors/ArgTypesError";
-import NativeDocumentError from "../errors/NativeDocumentError";
-
-/**
- *
- * @type {{string: (function(*): {name: *, type: string, validate: function(*): boolean}),
- *      number: (function(*): {name: *, type: string, validate: function(*): boolean}),
- *      boolean: (function(*): {name: *, type: string, validate: function(*): boolean}),
- *      observable: (function(*): {name: *, type: string, validate: function(*): boolean}),
- *      element: (function(*): {name: *, type: string, validate: function(*): *}),
- *      function: (function(*): {name: *, type: string, validate: function(*): boolean}),
- *      object: (function(*): {name: *, type: string, validate: function(*): boolean}),
- *      objectNotNull: (function(*): {name: *, type: string, validate: function(*): *}),
- *      children: (function(*): {name: *, type: string, validate: function(*): *}),
- *      attributes: (function(*): {name: *, type: string, validate: function(*): *}),
- *      optional: (function(*): *&{optional: boolean}),
- *      oneOf: (function(*, ...[*]): {name: *, type: string, types: *[],
- *      validate: function(*): boolean})
- * }}
- */
-export const ArgTypes = {
-    string: (name) => ({ name, type: 'string', validate: (v) => Validator.isString(v) }),
-    number: (name) => ({ name, type: 'number', validate: (v) => Validator.isNumber(v) }),
-    boolean: (name) => ({ name, type: 'boolean', validate: (v) => Validator.isBoolean(v) }),
-    observable: (name) => ({ name, type: 'observable', validate: (v) => Validator.isObservable(v) }),
-    element: (name) => ({ name, type: 'element', validate: (v) => Validator.isElement(v) }),
-    function: (name) => ({ name, type: 'function', validate: (v) => Validator.isFunction(v) }),
-    object: (name) => ({ name, type: 'object', validate: (v) => (Validator.isObject(v)) }),
-    objectNotNull: (name) => ({ name, type: 'object', validate: (v) => (Validator.isObject(v) && v !== null) }),
-    children: (name) => ({ name, type: 'children', validate: (v) => Validator.validateChildren(v) }),
-    attributes: (name) => ({ name, type: 'attributes', validate: (v) => Validator.validateAttributes(v) }),
-
-    // Optional arguments
-    optional: (argType) => ({ ...argType, optional: true }),
-
-    // Union types
-    oneOf: (name, ...argTypes) => ({
-        name,
-        type: 'oneOf',
-        types: argTypes,
-        validate: (v) => argTypes.some(type => type.validate(v))
-    })
-};
-
-/**
- *
- * @param {Array} args
- * @param {Array} argSchema
- * @param {string} fnName
- */
-const validateArgs = (args, argSchema, fnName = 'Function') => {
-    if (!argSchema) return;
-
-    const errors = [];
-
-    // Check the number of arguments
-    const requiredCount = argSchema.filter(arg => !arg.optional).length;
-    if (args.length < requiredCount) {
-        errors.push(`${fnName}: Expected at least ${requiredCount} arguments, got ${args.length}`);
-    }
-
-    // Validate each argument
-    argSchema.forEach((schema, index) => {
-        const position = index + 1;
-        const value = args[index];
-
-        if (value === undefined) {
-            if (!schema.optional) {
-                errors.push(`${fnName}: Missing required argument '${schema.name}' at position ${position}`);
-            }
-            return;
-        }
-
-        if (!schema.validate(value)) {
-            const valueTypeOf = value?.constructor?.name || typeof value;
-            errors.push(`${fnName}: Invalid argument '${schema.name}' at position ${position}, expected ${schema.type}, got ${valueTypeOf}`);
-        }
-    });
-
-    if (errors.length > 0) {
-        throw new ArgTypesError(`Argument validation failed`, errors);
-    }
-};
-
-/**
- * @param {Function} fn
- * @param {Array} argSchema
- * @param {string} fnName
- * @returns {Function}
- */
-export const withValidation = (fn, argSchema, fnName = 'Function') => {
-    if(!Validator.isArray(argSchema)) {
-        throw new NativeDocumentError('withValidation : argSchema must be an array');
-    }
-    return function(...args) {
-        validateArgs(args, argSchema, fn.name || fnName);
-        return fn.apply(this, args);
-    };
-};

package/src/utils/debug-manager.js

@@ -1,31 +0,0 @@
-const DebugManager = {
-    enabled: false,
-
-    enable() {
-        this.enabled = true;
-        console.log('🔍 NativeDocument Debug Mode enabled');
-    },
-
-    disable() {
-        this.enabled = false;
-    },
-
-    log(category, message, data) {
-        if (!this.enabled) return;
-        console.group(`🔍 [${category}] ${message}`);
-        if (data) console.log(data);
-        console.trace();
-        console.groupEnd();
-    },
-
-    warn(category, message, data) {
-        if (!this.enabled) return;
-        console.warn(`⚠️ [${category}] ${message}`, data);
-    },
-
-    error(category, message, error) {
-        console.error(`❌ [${category}] ${message}`, error);
-    }
-};
-
-export default DebugManager;

package/src/utils/helpers.js

@@ -1,60 +0,0 @@
-import Validator from "./validator";
-
-const invoke = function(fn, args, context) {
-    if(context) {
-        fn.apply(context, args);
-    } else {
-        fn(...args);
-    }
-};
-/**
- *
- * @param {Function} fn
- * @param {number} delay
- * @param {{leading?:Boolean, trailing?:Boolean, debounce?:Boolean, check: Function}}options
- * @returns {(function(...[*]): void)|*}
- */
-export const debounce = function(fn, delay, options = {}) {
-    let timer = null;
-    let lastArgs = null;
-
-    return  function(...args) {
-        const context = options.context === true ? this : null;
-        let scopeDelay = delay;
-        if(options.check) {
-            const response = options.check(...args);
-            if(typeof response === 'number') {
-                scopeDelay = response;
-            }
-        }
-        lastArgs = args;
-
-        // debounce mode: reset the timer for each call
-        clearTimeout(timer);
-        timer = setTimeout(() => invoke(fn, lastArgs, context), delay);
-    }
-};
-
-
-/**
- *
- * @param {*} item
- * @param {string|null} defaultKey
- * @param {?Function} key
- * @returns {*}
- */
-export const getKey = (item, defaultKey, key) => {
-    if(Validator.isFunction(key)) return key(item, defaultKey);
-    if(Validator.isObservable(item)) {
-        const val = item.val();
-        return (val && key) ? val[key] : defaultKey;
-    }
-    if(!Validator.isObject(item)) {
-        return item;
-    }
-    return item[key] ?? defaultKey;
-};
-
-export const trim = function(str, char) {
-    return str.replace(new RegExp(`^[${char}]+|[${char}]+$`, 'g'), '');
-}

package/src/utils/plugins-manager.js

@@ -1,12 +0,0 @@
-
-const pluginsManager = (function() {
-
-    const $plugins = [];
-
-    return {
-        list : () => $plugins,
-        add : (plugin) => $plugins.push(plugin)
-    };
-}());
-
-export default pluginsManager;

package/src/utils/prototypes.js

@@ -1,45 +0,0 @@
-import {withValidation} from "./args-types.js";
-import {Observable} from "../data/Observable";
-import Validator from "./validator";
-
-
-Function.prototype.args = function(...args) {
-    return withValidation(this, args);
-};
-
-Function.prototype.errorBoundary = function(callback) {
-    return (...args)  => {
-        try {
-            return this.apply(this, args);
-        } catch(e) {
-            return callback(e);
-        }
-    };
-};
-
-String.prototype.use = function(args) {
-    const value = this;
-
-    return Observable.computed(() => {
-        return value.replace(/\$\{(.*?)}/g, (match, key) => {
-            const data = args[key];
-            if(Validator.isObservable(data)) {
-                return data.val();
-            }
-            return data;
-        });
-    }, Object.values(args));
-};
-
-String.prototype.resolveObservableTemplate = function() {
-    if(!Validator.containsObservableReference(this)) {
-        return this;
-    }
-    return this.split(/(\{\{#ObItem::\([0-9]+\)\}\})/g).filter(Boolean).map((value) => {
-        if(!Validator.containsObservableReference(value)) {
-            return value;
-        }
-        const [_, id] = value.match(/\{\{#ObItem::\(([0-9]+)\)\}\}/);
-        return Observable.getById(id);
-    });
-}

package/src/wrappers/AttributesWrapper.js

@@ -1,144 +0,0 @@
-import Validator from "../utils/validator";
-import NativeDocumentError from "../errors/NativeDocumentError";
-import {BOOLEAN_ATTRIBUTES} from "./constants.js";
-import {Observable} from "../data/Observable";
-
-/**
- *
- * @param {HTMLElement} element
- * @param {Object} data
- */
-function bindClassAttribute(element, data) {
-    for(let className in data) {
-        const value = data[className];
-        if(Validator.isObservable(value)) {
-            element.classList.toggle(className, value.val());
-            value.subscribe(newValue => element.classList.toggle(className, newValue));
-            continue;
-        }
-        element.classList.toggle(className, value)
-    }
-}
-
-/**
- *
- * @param {HTMLElement} element
- * @param {Object} data
- */
-function bindStyleAttribute(element, data) {
-    for(let styleName in data) {
-        const value = data[styleName];
-        if(Validator.isObservable(value)) {
-            element.style[styleName] = value.val();
-            value.subscribe(newValue => {
-                element.style[styleName] = newValue;
-            });
-            continue;
-        }
-        element.style[styleName] = value;
-    }
-}
-
-/**
- *
- * @param {HTMLElement} element
- * @param {string} attributeName
- * @param {boolean|number|Observable} value
- */
-function bindBooleanAttribute(element, attributeName, value) {
-    const defaultValue = Validator.isObservable(value) ? value.val() : value;
-    if(Validator.isBoolean(defaultValue)) {
-        element[attributeName] = defaultValue;
-    }
-    else {
-        element[attributeName] = defaultValue === element.value;
-    }
-    if(Validator.isObservable(value)) {
-        if(['checked'].includes(attributeName)) {
-            element.addEventListener('input', () => {
-                if(Validator.isBoolean(defaultValue)) {
-                    value.set(element[attributeName]);
-                    return;
-                }
-                value.set(element.value);
-            });
-        }
-        value.subscribe(newValue => {
-            if(Validator.isBoolean(newValue)) {
-                element[attributeName] = newValue;
-                return;
-            }
-            element[attributeName] = newValue === element.value;
-        });
-    }
-}
-
-
-/**
- *
- * @param {HTMLElement} element
- * @param {string} attributeName
- * @param {Observable} value
- */
-function bindAttributeWithObservable(element, attributeName, value) {
-    const applyValue = (newValue) => {
-        if(attributeName === 'value') {
-            element.value = newValue;
-            return;
-        }
-        element.setAttribute(attributeName, newValue);
-    };
-    applyValue(value.val());
-    value.subscribe(applyValue);
-
-    if(attributeName === 'value') {
-        element.addEventListener('input', () => value.set(element.value));
-    }
-}
-
-/**
- *
- * @param {HTMLElement} element
- * @param {Object} attributes
- */
-export default function AttributesWrapper(element, attributes) {
-
-    Validator.validateAttributes(attributes);
-
-    if(!Validator.isObject(attributes)) {
-        throw new NativeDocumentError('Attributes must be an object');
-    }
-
-    for(let key in attributes) {
-        const attributeName = key.toLowerCase();
-        let value = attributes[attributeName];
-        if(Validator.isString(value) && Validator.isFunction(value.resolveObservableTemplate)) {
-            value = value.resolveObservableTemplate();
-            if(Validator.isArray(value)) {
-                const observables = value.filter(item => Validator.isObservable(item));
-                value = Observable.computed(() => {
-                    return value.map(item => Validator.isObservable(item) ? item.val() : item).join(' ') || ' ';
-                }, observables);
-            }
-        }
-        if(BOOLEAN_ATTRIBUTES.includes(attributeName)) {
-            bindBooleanAttribute(element, attributeName, value);
-            continue;
-        }
-        if(Validator.isObservable(value)) {
-            bindAttributeWithObservable(element, attributeName, value);
-            continue;
-        }
-        if(attributeName === 'class' && Validator.isJson(value)) {
-            bindClassAttribute(element, value);
-            continue;
-        }
-        if(attributeName === 'style' && Validator.isJson(value)) {
-            bindStyleAttribute(element, value);
-            continue;
-        }
-        element.setAttribute(attributeName, value);
-
-    }
-    return element;
-}

package/src/wrappers/DocumentObserver.js

@@ -1,80 +0,0 @@
-import {debounce} from "../utils/helpers";
-
-const DocumentObserver = {
-    mounted: new WeakMap(),
-    mountedSupposedSize: 0,
-    unmounted: new WeakMap(),
-    unmountedSupposedSize: 0,
-    observer: null,
-    checkMutation: debounce(function(mutationsList) {
-        let i = 0;
-        for(const mutation of mutationsList) {
-            if(DocumentObserver.mountedSupposedSize > 0 ) {
-                for(const node of mutation.addedNodes) {
-                    const data = DocumentObserver.mounted.get(node);
-                    if(!data) {
-                        continue;
-                    }
-                    data.inDom = true;
-                    data.mounted && data.mounted(node);
-                }
-            }
-
-            if(DocumentObserver.unmountedSupposedSize > 0 ) {
-                for(const node of mutation.removedNodes) {
-                    const data = DocumentObserver.unmounted.get(node);
-                    if(!data) {
-                        continue;
-                    }
-
-                    data.inDom = false;
-                    if(data.unmounted && data.unmounted(node) === true) {
-                        data.disconnect();
-                        node.nd?.remove();
-                    }
-                }
-            }
-        }
-    }, 16),
-    /**
-     *
-     * @param {HTMLElement} element
-     * @param {boolean} inDom
-     * @returns {{watch: (function(): Map<any, any>), disconnect: (function(): boolean), mounted: (function(*): Set<any>), unmounted: (function(*): Set<any>)}}
-     */
-    watch: function(element, inDom = false) {
-        let data = {
-            inDom,
-            mounted: null,
-            unmounted: null,
-            disconnect: () => {
-                DocumentObserver.mounted.delete(element);
-                DocumentObserver.unmounted.delete(element);
-                DocumentObserver.mountedSupposedSize--;
-                DocumentObserver.unmountedSupposedSize--;
-                data = null;
-            }
-        };
-
-        return {
-            disconnect: data.disconnect,
-            mounted: (callback) => {
-                data.mounted = callback;
-                DocumentObserver.mounted.set(element, data);
-                DocumentObserver.mountedSupposedSize++;
-            },
-            unmounted: (callback) => {
-                data.unmounted = callback;
-                DocumentObserver.unmounted.set(element, data);
-                DocumentObserver.unmountedSupposedSize++;
-            }
-        };
-    }
-};
-
-DocumentObserver.observer = new MutationObserver(DocumentObserver.checkMutation);
-DocumentObserver.observer.observe(document.body, {
-    childList: true,
-    subtree: true,
-});
-export default DocumentObserver;