igs-slm 0.1.0b0__py3-none-any.whl

slm/static/slm/js/fileIcons.js

@@ -0,0 +1,30 @@
+if (typeof slm === 'undefined' || slm == null) { var slm = {}; }
+
+
+slm.iconMap = {
+    'zip': 'bi bi-file-zip',
+    'x-tar': 'bi bi-file-zip',
+    'plain': 'bi bi-filetype-txt',
+    'jpeg': 'bi bi-filetype-jpg',
+    'svg+xml': 'bi bi-filetype-svg',
+    'xml': 'bi bi-filetype-xml',
+    'json': 'bi bi-filetype-json',
+    'png': 'bi bi-filetype-png',
+    'tiff': 'bi bi-filetype-tiff',
+    'pdf': 'bi bi-filetype-pdf',
+    'gif': 'bi bi-filetype-gif',
+    'csv': 'bi bi-filetype-csv',
+    'bmp': 'bi bi-filetype-bmp',
+    'vnd.openxmlformats-officedocument.wordprocessingml.document': 'bi bi-filetype-doc',
+    'msword': 'bi bi-filetype-doc'
+};
+
+slm.fileIcon = function(mimetype) {
+    if (mimetype) {
+        let subtype = mimetype.substring(mimetype.indexOf('/') + 1);
+        if (slm.iconMap.hasOwnProperty(subtype)) {
+            return slm.iconMap[subtype];
+        }
+    }
+    return "bi bi-file-earmark";
+};

slm/static/slm/js/form.js

@@ -0,0 +1,404 @@
+import { Persistable } from "./persistable.js";
+
+export class Form extends Persistable {
+    /**
+     * This class encapsulates reading and writing json data to/from html forms.
+     * This is less trivial than you might assume and there are some special case
+     * SLM field behavior (namely composition/decomposition) and custom input
+     * widgets that are handled.
+     */
+
+    element;
+    #initial;  // the "clear" state of the form
+    fields;
+    widgets;  // object keyed on field name where the values are widgets
+    last; // last serialized data
+
+    #multi;
+    #composite;
+
+    #changeCallbacks;
+
+    static ELEMENTS = ['input', 'select', 'textarea'];
+
+    static toBool = function(value) {
+        /**
+         * Convert a value to a boolean. Special string cases are handled.
+         */
+        if (typeof value === 'string' || value instanceof String) {
+            value = value.toLowerCase();
+            if (['yes', 'y', 'true', '1', 'on'].includes(value)) {
+                return true;
+            } else if (['no', 'n', 'false', '0', 'off'].includes(value)) {
+                return false;
+            }
+            else {
+                return null;
+            }
+        }
+        return Boolean(value);
+    }
+
+    static differs = function(state1, state2) {
+        /**
+         * Returns true if the given form states differ, false otherwise.
+         */
+        for (const [key, value] of Object.entries(state1)) {
+            if (state2.hasOwnProperty(key)) {
+                if (Array.isArray(value)) {
+                    if (
+                        Array.isArray(state2[key]) &&
+                        value.length === state2[key].length
+                    ) {
+                        for (let idx = 0; idx < value.length; idx++) {
+                            if (value[idx] !== state2[key][idx]) {
+                                return true;
+                            }
+                        }
+                    } else {
+                        return true;
+                    }
+                } else if (
+                    Array.isArray(state2[key]) ||
+                    value !== state2[key]
+                ) { return true; }
+            }
+        }
+        return false;
+    }
+
+    static stripNulls = function(data) {
+        /**
+         * Strip empty arrays and values from the query data.
+         * @type {{}}
+         */
+        const stripped = {};
+        for (const [key, value] of Object.entries(data)) {
+            if (value) { stripped[key] = value;}
+        }
+        return stripped;
+    }
+
+    static toQueryString = function(data) {
+        /**
+         * Convert query data to a url query string. No ? will be added
+         * to the front. This will strip nulls.
+         */
+        const params = [];
+        for (const [key, value] of Object.entries(data)) {
+            if (value) {
+                params.push(`${key}=${value}`);
+            }
+        }
+        return params.join('&');
+    }
+
+    get excluded() {
+        /** fields excluded from persistence */
+        return ['csrfmiddlewaretoken'];
+    }
+
+    get initial() {
+        /**
+         * Returns a copy of the initial form settings (i.e. the "clear" state
+         * of the form.
+         */
+        return JSON.parse(JSON.stringify(this.#initial));
+    }
+
+    set initial(initial) {
+        /**
+         * Set the initial (i.e. clear) state of the form - some fields may
+         * have default values.
+         *
+         * The initial state of each field is determined in order of precedence
+         * by:
+         *
+         * 1) The value defined for the field in data-slm-initial on the form
+         *    element.
+         * 2) The current value of the form on initialization for any excluded
+         *    fields.
+         * 3) The default (see default()) value for field type.
+         */
+        this.#initial = initial;
+        if (this.excluded.length > 0) {
+            const data = this.data;
+            for (const field of this.excluded) {
+                if (this.fields.has(field)) {
+                    this.#initial[field] = data[field];
+                }
+            }
+        }
+        for (const field of this.fields) {
+            if (!this.#initial.hasOwnProperty(field)) {
+                this.#initial[field] = this.default(field);
+            }
+        }
+    }
+
+    get data() {
+        /**
+         * Get the JSON representing the form.
+         *
+         * If multiple input elements exist with the same name and different
+         * types, that is considered a composite field. It will be combined
+         * into a single field using compose. The reverse operation is
+         * decompose.
+         *
+         * Multiple input elements that exist with the same name and the same
+         * type will be turned into arrays where the array elements are the
+         * values of the activated elements (checkboxes and selects).
+         *
+         */
+        const data = {};
+
+        const coerceValue = function(fieldName, value) {
+            if (!this.isMulti(fieldName) && this.type(fieldName) === 'checkbox') {
+                return Form.toBool(value);
+            }
+            return value;
+        }.bind(this);
+
+        // flatten name/value objects into name: value or name: array[values]
+        for (const field of this.element.serializeArray()) {
+            let value = coerceValue(field.name, field.value);
+            if (this.isMulti(field.name)) {
+                if (Array.isArray(data[field.name])) {
+                    data[field.name].push(value);
+                } else {
+                    data[field.name] = [value];
+                }
+            } else {
+                data[field.name] = value;
+            }
+        }
+
+        // compose any composite fields
+        for (const [field, value] of Object.entries(data)) {
+            if (this.isComposite(field)) {
+                data[field] = this.compose(this.type(field), value);
+            }
+        }
+
+        for (const field of this.fields) {
+            if (!data.hasOwnProperty(field)) {
+                data[field] = this.default(field);
+            }
+        }
+
+        return data;
+    }
+
+    set data(data) {
+        /**
+         * Populates a form from the given json object. Keys should correspond
+         * to element names. Values are either singular or are arrays. Array
+         * values are expected to correspond to the value attributes of select
+         * options or checkboxes.
+         *
+         * If a form has multiple fields of different types with the same name
+         * that field value is decomposed using decompose() into a value for
+         * each input element.
+         *
+         * @type {any}
+         */
+        
+        // form updates must be total - any missing fields will be defaulted
+        data = Object.assign(this.initial, data);
+
+        const setField = function(ipt, value) {
+            switch (ipt.prop('type')) {
+                case 'radio':
+                case 'checkbox':
+                    ipt.each(function () {
+                        $(this).prop('checked', Form.toBool(value));
+                    });
+                    break;
+                default:
+                    ipt.val(value);
+            }
+        }
+
+        $.each(data, function (field, value) {
+            const ipt = this.field(field);
+            if (Array.isArray(value)) {
+                switch (ipt.prop('type')) {
+                    case 'select': case 'select-multiple':
+                        const selected = [];
+                        for (const val of value) { selected.push(`option[value="${val}"]`); }
+                        ipt.find(selected.join(', ')).prop('selected', true);
+                        ipt.find('option').not(selected).prop('selected', false);
+                        break;
+                    case 'checkbox':
+                        let checked = [];
+                        for (const val of value) { checked.push(`[name="${field}"][value="${val}"]:checkbox`); }
+                        checked = this.element.find(checked.join(', '));
+                        checked.prop('checked', true);
+                        this.element.find(`[name="${field}"]:checkbox`).not(checked).prop('checked', false);
+                        break;
+                    default:
+                        if (ipt.length > 0) {
+                            throw TypeError(`Array given for form data type: ${ipt.prop('type')}`);
+                        }
+                }
+            } else if (ipt.length > 1) {
+                const types = [];
+                ipt.each(function () { types.push($(this).prop('type')); });
+                const values = this.decompose(types, value);
+                ipt.map((e, i) => { setField(e, values[i]); });
+            } else { setField(ipt, value); }
+        }.bind(this));
+
+        for (const widget of Object.values(this.widgets)) {
+            widget.changed();
+        }
+    }
+    
+    constructor(element) {
+        super(element);
+        this.element = element;
+        this.#composite = {};
+        this.#multi = new Set();
+        this.#changeCallbacks = [];
+        this.widgets = {};
+        
+        // Step one is to determine which names are not unique. These fields are
+        // either array-value fields or if the types differ they are composed.
+        this.fields = new Set();
+        this.element.find(Form.ELEMENTS.join(',')).each((idx, ipt) => {
+            this.fields.add($(ipt).prop('name'));
+        })
+        for (const field of this.fields) {
+            const inputs = this.element.find(this.field(field));
+            if (inputs.data('widget')) {
+                this.widgets[field] = inputs.data('widget');
+            }
+            if (inputs.length > 1) {
+                const types = new Set();
+                inputs.each((idx, element) => {
+                    types.add($(element).prop('type'));
+                });
+                types.size > 1 ? this.#composite[field] = types : this.#multi.add(field);
+            } else if (inputs.get(0).hasAttribute('multiple')) {
+                this.#multi.add(field);
+            }
+        }
+
+        if (this.element.data('slmInitial')) {
+            this.initial = this.element.data('slmInitial');
+        } else {
+            this.initial = {};
+        }
+
+        this.element.data('slmForm', this);
+
+        this.element.find(':input').on('change', function() {
+            const data = this.data;
+            if (Form.differs(data, this.last)) {
+                for (const changed of this.#changeCallbacks) { changed(this); }
+                this.last = data;
+            }
+        }.bind(this));
+
+        this.last = this.data;
+    }
+
+    decompose(types, value) {
+        switch (types) {
+            case ['date', 'time']:
+                if (value) { return value.split('T'); }
+                return ['', ''];
+            default:
+                throw TypeError(`Unexpected decomposition types: ${types}`);
+        }
+    }
+
+    compose(types, inputs) {
+        switch (types) {
+            case ['date', 'time']:
+                return `${inputs.get(0).value}T${inputs.get(1).value || "00:00"}Z`
+            default:
+                throw TypeError(`Unexpected composition types: ${types}`);
+        }
+    }
+
+    clear() {
+        this.data = this.initial;
+    }
+
+    isComposite(field) {
+        return this.#composite.hasOwnProperty(field);
+    }
+
+    isMulti(field) {
+        return this.#multi.has(field);
+    }
+    
+    type(field) {
+        if (this.isComposite(field)) {
+            return this.#composite[field];
+        }
+        return this.field(field).prop('type');
+    }
+    
+    default(field) {
+        if (this.isMulti(field)) {
+            return [];
+        } else if (this.isComposite(field)) {
+            return this.decompose(this.type(field), '');
+        }
+        switch(this.type(field)) {
+            case 'checkbox':
+            case 'radio':
+                return false;
+            default:
+                return '';
+        }
+    }
+
+    field(name) {
+        return this.element.find(
+            Form.ELEMENTS.join(`[name="${name}"],`) + `[name="${name}"]`
+        );
+    }
+
+    hasChanged() {
+        /**
+         * Returns true if this form differs from its initial "clear" state and
+         * false otherwise.
+         */
+        return Form.differs(this.data, this.initial);
+    }
+
+    persist() {
+        /**
+         * Persist this form's current state to session memory.
+         */
+        const current = this.data;
+        // never persist excluded fields
+        for (const field of this.excluded) {
+            if (current.hasOwnProperty(field)) {
+                delete current[field];
+            }
+        }
+        this.persisted = current;
+        for (const widget of Object.values(this.widgets)) {
+            widget.persist();
+        }
+    }
+
+    revive() {
+        /**
+         * Revive this form's current state from session memory, if it has
+         * been persisted.
+         */
+        this.data = this.persisted;
+        for (const widget of Object.values(this.widgets)) {
+            widget.revive();
+        }
+    }
+
+    onChange(callback) {
+        this.#changeCallbacks.push(callback);
+    }
+}

slm/static/slm/js/formWidget.js

@@ -0,0 +1,23 @@
+import { Persistable } from './persistable.js'
+
+export class FormWidget extends Persistable {
+
+    #container;
+
+    get container() {
+        return this.#container;
+    }
+
+    constructor(container) {
+        super(container.get(0).getAttribute('id'));
+        this.#container = container;
+    }
+
+    changed() {
+        /**
+         * Deriving widgets should implement this callback which is invoked
+         * when the underlying widget's state has changed.
+         */
+    }
+
+}

slm/static/slm/js/persistable.js

@@ -0,0 +1,33 @@
+export class Persistable {
+    /**
+     * A simple interface defining a persistable component. Data is persisted
+     * in session memory.
+     */
+
+    key;
+
+    get persisted() {
+        const store = sessionStorage.getItem(this.key);
+        if (store) {
+            return JSON.parse(sessionStorage.getItem(this.key));
+        }
+        return {}
+    }
+
+    set persisted(data) {
+        sessionStorage.setItem(this.key, JSON.stringify(data));
+    }
+
+    constructor(key) {
+        this.key = key;
+    }
+
+    persist() {/* Deriving classes define their own persist logic */}
+
+    revive() {
+        /*
+         * Deriving classes define their own revival logic, this method
+         * should restore persisted state to the component
+         */
+    }
+}