simplyview 2.1.0 → 3.0.0

package/js/simply.include.js

@@ -1,226 +0,0 @@
-(function (global) {
-    'use strict';
-
-    var throttle = function( callbackFunction, intervalTime ) {
-        var eventId = 0;
-        return function() {
-            var myArguments = arguments;
-            var me = this;
-            if ( eventId ) {
-                return;
-            } else {
-                eventId = global.setTimeout( function() {
-                    callbackFunction.apply(me, myArguments);
-                    eventId = 0;
-                }, intervalTime );
-            }
-        };
-    };
-
-    var runWhenIdle = (function() {
-        if (global.requestIdleCallback) {
-            return function(callback) {
-                global.requestIdleCallback(callback, {timeout: 500});
-            };
-        }
-        return global.requestAnimationFrame;
-    })();
-
-    var rebaseHref = function(relative, base) {
-        if (/^[a-z-]*:?\//.test(relative)) {
-            return relative; // absolute href, no need to rebase
-        }
-
-        var stack = base.split('/'),
-            parts = relative.split('/');
-        stack.pop(); // remove current file name (or empty string)
-        for (var i=0; i<parts.length; i++) {
-            if (parts[i] == '.')
-                continue;
-            if (parts[i] == '..')
-                stack.pop();
-            else
-                stack.push(parts[i]);
-        }
-        return stack.join('/');
-    };
-
-    var observer, loaded = {};
-    var head = global.document.querySelector('head');
-    var currentScript = global.document.currentScript;
-    if (!currentScript) {
-        var getScriptURL = (function() {
-            var scripts = document.getElementsByTagName('script');
-            var index = scripts.length - 1;
-            var myScript = scripts[index];
-            return function() { return myScript.src; };
-        })();
-        var currentScriptURL = getScriptURL();
-    } else {
-        var currentScriptURL = currentScript.src;
-    }
-
-    var waitForPreviousScripts = function() {
-        // because of the async=false attribute, this script will run after
-        // the previous scripts have been loaded and run
-        // simply.include.next.js only fires the simply-next-script event
-        // that triggers the Promise.resolve method
-        return new Promise(function(resolve) {
-            var next = global.document.createElement('script');
-            next.src = rebaseHref('simply.include.next.js', currentScriptURL);
-            next.async = false;
-            global.document.addEventListener('simply-include-next', function() {
-                head.removeChild(next);
-                resolve();
-            }, { once: true, passive: true});
-            head.appendChild(next);
-        });
-    };
-
-    var scriptLocations = [];
-
-    var include = {
-        scripts: function(scripts, base) {
-            var arr = [];
-            for(var i = scripts.length; i--; arr.unshift(scripts[i]));
-            var importScript = function() {
-                var script = arr.shift();
-                if (!script) {
-                    return;
-                }
-                var attrs  = [].map.call(script.attributes, function(attr) {
-                    return attr.name;
-                });
-                var clone  = global.document.createElement('script');
-                attrs.forEach(function(attr) {
-                    clone.setAttribute(attr, script.getAttribute(attr));
-                });
-                clone.removeAttribute('data-simply-location');
-                if (!clone.src) {
-                    // this is an inline script, so copy the content and wait for previous scripts to run
-                    clone.innerHTML = script.innerHTML;
-                    waitForPreviousScripts()
-                        .then(function() {
-                            var node = scriptLocations[script.dataset.simplyLocation];
-                            node.parentNode.insertBefore(clone, node);
-                            node.parentNode.removeChild(node);
-                            importScript();
-                        });
-                } else {
-                    clone.src = rebaseHref(clone.src, base);
-                    if (!clone.hasAttribute('async') && !clone.hasAttribute('defer')) {
-                        clone.async = false; //important! do not use clone.setAttribute('async', false) - it has no effect
-                    }
-                    var node = scriptLocations[script.dataset.simplyLocation];
-                    node.parentNode.insertBefore(clone, node);
-                    node.parentNode.removeChild(node);
-                    loaded[clone.src]=true;
-                    importScript();
-                }
-            };
-            if (arr.length) {
-                importScript();
-            }
-        },
-        html: function(html, link) {
-            var fragment = global.document.createRange().createContextualFragment(html);
-            var stylesheets = fragment.querySelectorAll('link[rel="stylesheet"],style');
-            // add all stylesheets to head
-            [].forEach.call(stylesheets, function(stylesheet) {
-                if (stylesheet.href) {
-                    stylesheet.href = rebaseHref(stylesheet.href, link.href);
-                }
-                head.appendChild(stylesheet);
-            });
-            // remove the scripts from the fragment, as they will not run in the
-            // order in which they are defined
-            var scriptsFragment = global.document.createDocumentFragment();
-            // FIXME: this loses the original position of the script
-            // should add a placeholder so we can reinsert the clone
-            var scripts = fragment.querySelectorAll('script');
-            [].forEach.call(scripts, function(script) {
-                var placeholder = global.document.createComment(script.src || 'inline script');
-                script.parentNode.insertBefore(placeholder, script);
-                script.dataset.simplyLocation = scriptLocations.length;
-                scriptLocations.push(placeholder);
-                scriptsFragment.appendChild(script);
-            });
-            // add the remainder before the include link
-            link.parentNode.insertBefore(fragment, link ? link : null);
-            global.setTimeout(function() {
-                if (global.editor && global.editor.data && fragment.querySelector('[data-simply-field],[data-simply-list]')) {
-                    //TODO: remove this dependency and let simply.bind listen for dom node insertions (and simply-edit.js use simply.bind)
-                    global.editor.data.apply(global.editor.currentData, global.document);
-                }
-                simply.include.scripts(scriptsFragment.childNodes, link ? link.href : global.location.href );
-            }, 10);
-        }
-    };
-
-    var included = {};
-    var includeLinks = function(links) {
-        // mark them as in progress, so handleChanges doesn't find them again
-        var remainingLinks = [].reduce.call(links, function(remainder, link) {
-            if (link.rel=='simply-include-once' && included[link.href]) {
-                link.parentNode.removeChild(link);
-            } else {
-                included[link.href]=true;
-                link.rel = 'simply-include-loading';
-                remainder.push(link);
-            }
-            return remainder;
-        }, []);
-        [].forEach.call(remainingLinks, function(link) {
-            if (!link.href) {
-                return;
-            }
-            // fetch the html
-            fetch(link.href)
-                .then(function(response) {
-                    if (response.ok) {
-                        console.log('simply-include: loaded '+link.href);
-                        return response.text();
-                    } else {
-                        console.log('simply-include: failed to load '+link.href);
-                    }
-                })
-                .then(function(html) {
-                    // if succesfull import the html
-                    simply.include.html(html, link);
-                    // remove the include link
-                    link.parentNode.removeChild(link);
-                });
-        });
-    };
-
-    var handleChanges = throttle(function() {
-        runWhenIdle(function() {
-            var links = global.document.querySelectorAll('link[rel="simply-include"],link[rel="simply-include-once"]');
-            if (links.length) {
-                includeLinks(links);
-            }
-        });
-    });
-
-    var observe = function() {
-        observer = new MutationObserver(handleChanges);
-        observer.observe(global.document, {
-            subtree: true,
-            childList: true,
-        });
-    };
-
-    observe();
-    handleChanges(); // check if there are include links in the dom already
-
-    if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {
-        module.exports = include;
-    } else {
-        if (!global.simply) {
-            global.simply = {};
-        }
-        global.simply.include = include;
-    }
-
-
-})(this);

package/js/simply.keyboard.js

@@ -1,62 +0,0 @@
-(function(global) {
-    'use strict';
-
-    function keyboard(app, config) {
-        var keys = config;
-
-        if (!app) {
-            app = {};
-        }
-        if (!app.container) {
-            app.container = document.body;
-        }
-        app.container.addEventListener('keydown', (e) => {
-            if (e.isComposing || e.keyCode === 229) {
-                return;
-            }
-            if (e.defaultPrevented) {
-                return;
-            }
-            if (!e.target) {
-                return;
-            }
-
-            let selectedKeyboard = 'default';
-            if (e.target.closest('[data-simply-keyboard]')) {
-                selectedKeyboard = e.target.closest('[data-simply-keyboard]').dataset.simplyKeyboard;
-            }
-            let key = '';
-            if (e.ctrlKey && e.keyCode!=17) {
-                key+='Control+';
-            }
-            if (e.metaKey && e.keyCode!=224) {
-                key+='Meta+';
-            }
-            if (e.altKey && e.keyCode!=18) {
-                key+='Alt+';
-            }
-            if (e.shiftKey && e.keyCode!=16) {
-                key+='Shift+';
-            }
-            key+=e.key;
-
-            if (keys[selectedKeyboard] && keys[selectedKeyboard][key]) {
-                let keyboard = keys[selectedKeyboard]
-                keyboard.app = app;
-                keyboard[key].call(keyboard,e);
-            }
-        });
-
-        return keys;
-    }
-
-
-    if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {
-        module.exports = keyboard;
-    } else {
-        if (!global.simply) {
-            global.simply = {};
-        }
-        global.simply.keyboard = keyboard;
-    }
-})(this);

package/js/simply.modules.js

@@ -1,22 +0,0 @@
-(function() {
-    if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {
-        var simply = {
-            command: require('simply.command.js'),
-            action:  require('simply.action.js'),
-            route:   require('simply.route.js'),
-            view:    require('simply.view.js'),
-			viewmodel: require('simply.viewmodel.js'),
-            resize:  require('simply.resize.js'),
-            activate:require('simply.active.js'),
-            include: require('simply.include.js'),
-            render:  require('simply.render.js'),
-            observe: require('simply.observe.js'),
-            bind:    require('simply.bind.js'),
-            app:     require('simply.app.js'),
-            collect: require('simply.collect.js'),
-            path:    require('simply.path.js')
-        }
-
-        module.exports = simply;
-    }
-})();

package/js/simply.observe.js

@@ -1,349 +0,0 @@
-/**
- * simply.observe
- * This component lets you observe changes in a json compatible data structure
- * It doesn't support linking the same object multiple times
- * It doesn't register deletion of properties using the delete keyword, assign
- * null to the property instead.
- * It doesn't register addition of new properties.
- * It doesn't register directly assigning new entries in an array on a previously
- * non-existant index.
- *
- * usage:
- *
- * (function) simply.observe( (object) model, (string) path, (function) callback)
- *
- * var model = { foo: { bar: 'baz' } };
- * var removeObserver = simply.observe(model, 'foo.bar', function(value, sourcePath) {
- *   console.log(sourcePath+': '+value);
- * };
- *
- * The function returns a function that removes the observer when called.
- *
- * The component can observe in place changes in arrays, either by changing
- * an item in a specific index, by calling methods on the array that change
- * the array in place or by reassigning the array with a new value.
- *
- * The sourcePath contains the exact entry that was changed, the value is the
- * value for the path passed to simply.observe.
- * If an array method was called that changes the array in place, the sourcePath
- * also contains that method and its arguments JSON serialized.
- *
- * sourcePath parts are always seperated with '.', even for array indexes.
- * so if foo = [ 'bar' ], the path to 'bar' would be 'foo.0'
- */
-
- /*
- FIXME: child properties added after initial observe() call aren't added to the
- childListeners. onMissingChildren can't then find them.
- TODO: onMissingChildren must loop through all fields to get only the direct child
-properties for a given parent, keep seperate index for this?
- */
-
-(function (global) {
-    'use strict';
-
-    var changeListeners = new WeakMap();
-    var parentListeners = new WeakMap();
-    var childListeners = new WeakMap();
-    var changesSignalled = {};
-    var observersPaused = 0;
-
-    function signalChange(model, path, value, sourcePath) {
-        if (observersPaused) {
-            return;
-        }
-
-        sourcePath = sourcePath ? sourcePath : path;
-        changesSignalled = {};
-
-        var signalRecursion = function(model, path, value, sourcePath) {
-            if (changeListeners.has(model) && changeListeners.get(model)[path]) {
-                // changeListeners[model][path] contains callback methods
-                changeListeners.get(model)[path].forEach(function(callback) {
-                    changesSignalled[path] = true;
-                    callback(value, sourcePath);
-                });
-            }
-        };
-
-        //TODO: check if this is correct
-        //previous version only triggered parentListeners when no changeListeners were
-        //triggered. that created problems with arrays. make an exhaustive unit test.
-        signalRecursion(model, path, value, sourcePath);
-        
-        if (parentListeners.has(model) && parentListeners.get(model)[path]) {
-            // parentListeners[model][path] contains child paths to signal change on
-            // if a parent object is changed, this signals the change to the child objects
-            parentListeners.get(model)[path].forEach(function(childPath) {
-                if (!changesSignalled[childPath]) {
-                    var value = getByPath(model, childPath);
-                    if (value) {
-                        attach(model, childPath);
-                    }
-                    signalRecursion(model, childPath, value, sourcePath);
-                    changesSignalled[childPath] = true;
-                }
-            });
-        }
-
-        if (childListeners.has(model) && childListeners.get(model)[path]) {
-            // childListeners[model][path] contains parent paths to signal change on
-            // if a child object is changed, this signals the change to the parent objects
-            childListeners.get(model)[path].forEach(function(parentPath) {
-                if (!changesSignalled[parentPath]) {
-                    var value = getByPath(model, parentPath);
-                    signalRecursion(model, parentPath, value, sourcePath);
-                    changesSignalled[parentPath] = true;
-                    // check if the parent object still has this child property
-                    //FIXME: add a setter trigger here to restore observers once the child property get set again
-
-                }
-            });
-        }
-
-    }
-
-    function getByPath(model, path) {
-        var parts = path.split('.');
-        var curr = model;
-        do {
-            curr = curr[parts.shift()];
-        } while (parts.length && curr);
-        return curr;
-    }
-
-    function parent(path) {
-        var parts = path.split('.');
-        parts.pop();
-        return parts.join('.');
-    }
-    
-    function head(path) {
-        return path.split('.').shift();
-    }
-
-    function onParents(model, path, callback) {
-        var parent = '';
-        var parentOb = model;
-        var parents = path.split('.');
-        do {
-            var head = parents.shift();
-            if (parentOb && typeof parentOb[head] != 'undefined') {
-                callback(parentOb, head, (parent ? parent + '.' + head : head));
-                parentOb = parentOb[head];
-            }
-            parent = (parent ? parent + '.' + head : head );
-        } while (parents.length);
-    }
-
-    function onChildren(model, path, callback) {
-        var onChildObjects = function(object, path, callback) {
-            if (typeof object != 'object' || object == null) {
-                return;
-            }
-            if (Array.isArray(object)) {
-                return;
-            }
-            // register the current keys
-            Object.keys(object).forEach(function(key) {
-                callback(object, key, path+'.'+key);
-                onChildObjects(object[key], path+'.'+key, callback);
-            });
-        };
-        var parent = getByPath(model, path);
-        onChildObjects(parent, path, callback);
-    }
-
-    function onMissingChildren(model, path, callback) {
-        var allChildren = Object.keys(childListeners.get(model) || []).filter(function(childPath) {
-            return childPath.substr(0, path.length)==path && childPath.length>path.length;
-        });
-        if (!allChildren.length) {
-            return;
-        }
-        var object = getByPath(model, path);
-        var keysSeen = {};
-        allChildren.forEach(function(childPath) {
-            var key = head(childPath.substr(path.length+1));
-            if (typeof object[key] == 'undefined') {
-                if (!keysSeen[key]) {
-                    callback(object, key, path+'.'+key);
-                    keysSeen[key] = true;
-                }
-            } else {
-                onMissingChildren(model, path+'.'+key, callback);
-            }
-        });
-    }
-
-    function addChangeListener(model, path, callback) {
-        if (!changeListeners.has(model)) {
-            changeListeners.set(model, {});
-        }
-        if (!changeListeners.get(model)[path]) {
-            changeListeners.get(model)[path] = [];
-        }
-        changeListeners.get(model)[path].push(callback);
-
-        if (!parentListeners.has(model)) {
-            parentListeners.set(model, {});
-        }
-        var parentPath = parent(path);
-        onParents(model, parentPath, function(parentOb, key, currPath) {
-            if (!parentListeners.get(model)[currPath]) {
-                parentListeners.get(model)[currPath] = [];
-            }
-            parentListeners.get(model)[currPath].push(path);
-        });
-
-        if (!childListeners.has(model)) {
-            childListeners.set(model, {});
-        }
-        onChildren(model, path, function(childOb, key, currPath) {
-            if (!childListeners.get(model)[currPath]) {
-                childListeners.get(model)[currPath] = [];
-            }
-            childListeners.get(model)[currPath].push(path);
-        });
-    }
-
-    function removeChangeListener(model, path, callback) {
-        if (!changeListeners.has(model)) {
-            return;
-        }
-        if (changeListeners.get(model)[path]) {
-            changeListeners.get(model)[path] = changeListeners.get(model)[path].filter(function(f) {
-                return f != callback;
-            });
-        }
-    }
-
-    function pauseObservers() {
-        observersPaused++;
-    }
-
-    function resumeObservers() {
-        observersPaused--;
-    }
-
-    function attach(model, path, options) {
-
-        var attachArray = function(object, path) {
-            var desc = Object.getOwnPropertyDescriptor(object, 'push');
-            if (!desc || desc.configurable) {
-                for (var f of ['push','pop','reverse','shift','sort','splice','unshift','copyWithin']) {
-                    (function(f) {
-                        try {
-                            Object.defineProperty(object, f, {
-                                value: function() {
-                                    pauseObservers();
-                                    var result = Array.prototype[f].apply(this, arguments);
-                                    attach(model, path);
-                                    var args = [].slice.call(arguments).map(function(arg) {
-                                        return JSON.stringify(arg);
-                                    });
-                                    resumeObservers();
-                                    signalChange(model, path, this, path+'.'+f+'('+args.join(',')+')');
-                                    return result;
-                                },
-                                readable: false,
-                                enumerable: false,
-                                configurable: false
-                            });
-                        } catch(e) {
-                            console.error('simply.observer: Error: Couldn\'t redefine array method '+f+' on '+path, e);
-                        }
-                    }(f));
-                }
-                for (var i=0, l=object.length; i<l; i++) {
-                    //FIXME: options becomes undefined here somewhere
-//                    if (options.skipArray) {
-                        addSetter(object, i, path+'.'+i);
-//                    } else {
-//                        attach(model, path+'.'+i, options);
-//                    }
-                }
-            }
-        };
-
-        var addSetTrigger = function(object, key, currPath) {
-            Object.defineProperty(object, key, {
-                set: function(value) {
-                    addSetter(object, key, currPath);
-                    object[key] = value;
-                },
-                configurable: true,
-                readable: false,
-                enumerable: false
-            });
-        };
-
-        var addSetter = function(object, key, currPath) {
-            if (Object.getOwnPropertyDescriptor(object, key).configurable) {
-                // assume object keys are only unconfigurable if the
-                // following code has already been run on this property
-                var _value = object[key];
-                Object.defineProperty(object, key, {
-                    set: function(value) {
-                        _value = value;
-                        signalChange(model, currPath, value);
-                        if (value!=null) {
-                            onChildren(model, currPath, addSetter);
-                            onMissingChildren(model, currPath, addSetTrigger);
-                        }
-                    },
-                    get: function() {
-                        return _value;
-                    },
-                    configurable: false,
-                    readable: true,
-                    enumerable: true
-                });
-            }
-            if (Array.isArray(object[key])) {
-                attachArray(object[key], currPath, options);
-            }
-        };
-
-        onParents(model, path, addSetter);
-        onChildren(model, path, addSetter);
-    }
-
-    // FIXME: if you remove a key by reassigning the parent object
-    // and then assign that missing key a new value
-    // the observer doesn't get triggered
-    // var model = { foo: { bar: 'baz' } };
-    // simply.observer(model, 'foo.bar', ...)
-    // model.foo = { }
-    // model.foo.bar = 'zab'; // this should trigger the observer but doesn't
-
-    var observe = function(model, path, callback, options) {
-        if (!path) {
-            var keys = Object.keys(model);
-            keys.forEach(function(key) {
-                attach(model, key, options);
-                addChangeListener(model, key, callback);
-            }); 
-            return function() {
-                keys.forEach(function(key) {
-                    removeChangeListener(model, key, callback);
-                });
-            };
-        } else {
-            attach(model, path, options);
-            addChangeListener(model, path, callback);
-            return function() {
-                removeChangeListener(model, path, callback);
-            };
-        }
-    };
-
-    if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {
-        module.exports = observe;
-    } else {
-        if (!global.simply) {
-            global.simply = {};
-        }
-        global.simply.observe = observe;
-    }
-})(this);