igs-slm 0.1.0b0__py3-none-any.whl

slm/static/slm/img/slm-logo.svg

@@ -0,0 +1,4 @@
+<svg width="50" height="50" viewBox="0 0 50 50" fill="none" xmlns="http://www.w3.org/2000/svg">
+<circle cx="25" cy="25" r="25" fill="white"/>
+<path d="M10.8974 25.641C10.8974 23.6752 11.266 21.8376 12.0032 20.1282C12.7404 18.4188 13.75 16.9284 15.0321 15.6571C16.3141 14.3857 17.8098 13.3814 19.5192 12.6442C21.2286 11.9071 23.0556 11.5385 25 11.5385C26.9444 11.5385 28.7714 11.9071 30.4808 12.6442C32.1902 13.3814 33.6859 14.3857 34.9679 15.6571C36.25 16.9284 37.2596 18.4188 37.9968 20.1282C38.734 21.8376 39.1026 23.6752 39.1026 25.641H37.1795C37.1795 23.953 36.859 22.3665 36.2179 20.8814C35.5769 19.3964 34.7062 18.1036 33.6058 17.0032C32.5053 15.9028 31.2126 15.0374 29.7276 14.4071C28.2425 13.7767 26.6667 13.4615 25 13.4615C23.3333 13.4615 21.7575 13.7767 20.2724 14.4071C18.7874 15.0374 17.4947 15.9028 16.3942 17.0032C15.2938 18.1036 14.4231 19.3964 13.7821 20.8814C13.141 22.3665 12.8205 23.953 12.8205 25.641H10.8974ZM16.5064 25.641C16.5064 23.2692 17.3344 21.2607 18.9904 19.6154C20.6464 17.9701 22.6496 17.1474 25 17.1474C27.3504 17.1474 29.3536 17.9701 31.0096 19.6154C32.6656 21.2607 33.4936 23.2692 33.4936 25.641H31.5705C31.5705 23.8034 30.9295 22.2489 29.6474 20.9776C28.3654 19.7062 26.8162 19.0705 25 19.0705C23.1838 19.0705 21.6346 19.7062 20.3526 20.9776C19.0705 22.2489 18.4295 23.8034 18.4295 25.641H16.5064ZM21.1538 38.9744L19.8077 37.6282L24.0385 33.3974V28.3974C23.4615 28.141 22.9968 27.7618 22.6442 27.2596C22.2917 26.7575 22.1154 26.218 22.1154 25.641C22.1154 24.8291 22.3932 24.1453 22.9487 23.5897C23.5043 23.0342 24.188 22.7564 25 22.7564C25.812 22.7564 26.4957 23.0342 27.0513 23.5897C27.6068 24.1453 27.8846 24.8291 27.8846 25.641C27.8846 26.218 27.7083 26.7575 27.3558 27.2596C27.0032 27.7618 26.5385 28.141 25.9615 28.3974V33.3974L30.1923 37.6282L28.8462 38.9744L25 35.1282L21.1538 38.9744Z" fill="black"/>
+</svg>

slm/static/slm/js/autocomplete.js

@@ -0,0 +1,341 @@
+import { FormWidget } from "./formWidget.js";
+
+export class AutoComplete extends FormWidget {
+    /**
+     * https://api.jqueryui.com/autocomplete/
+     *
+     * Expects the following data parameters on the auto complete container:
+     *
+     * data-service-url: (required) The url to fetch suggestions from ajax
+     * data-search-param: (required) The url query parameter to use for the search string
+     * data-label-param: (optional) The property to use as the label (default: search-param)
+     * data-value-param: (optional) The property to use as the value (default: label-param)
+     * data-renderSuggestion: (optional) A javascript function body accepting an obj argument and
+     *  returning a string label to use for the suggestion.
+     *
+     *  When providing a render suggestion, text that is searchable should be
+     *  wrapped in <span class="matchable"></span>
+     */
+
+    textInput;
+    formField;
+
+    paramName;
+    serviceUrl;
+    valueParam;
+    selected;
+
+    // if theres a full match on the first suggestion when the field is
+    // defocused (enter or click away) we set the value to that first match.
+    newResponse; // toggle used to only check the first menu item
+    fullMatch;
+    firstSuggestion;
+
+    renderSuggestion(suggestion) {
+        return `<span class="matchable">${suggestion[this.labelParam]}</span>`;
+    }
+
+    inputUpdated() {
+        /**
+         * When a user changes search text, we unset the set value if one is
+         * set, remove any html, reset the search box to the raw search string
+         * and set the cursor to the end.
+         */
+        const label = this.textInput.html();
+        const searchStr = this.textInput.find('.matchable').text();
+        const value = this.formField.val();
+        if (value) {
+            if (label !== this.selected[value]) {
+                this.remove(this.formField.val());
+                this.textInput.html(searchStr);
+                let sel = window.getSelection();
+                sel.selectAllChildren(this.textInput.get(0));
+                sel.collapseToEnd();
+            }
+        }
+    }
+
+    getSuggestion(value) {
+        /**
+         * Return the suggestion exactly matching the value.
+         */
+        const query = {};
+        query[this.valueParam] = value;
+        let suggestion = null;
+        $.ajax({
+            url: this.serviceUrl,
+            data: query,
+            async: false
+        }).done(
+            function(data) {
+                if (data.length > 0) {
+                    suggestion = this.makeSuggestion(data[0]);
+                }
+            }.bind(this)
+        ).fail(function(jqXHR) {console.log(jqXHR);});
+        return suggestion;
+    }
+
+    makeSuggestion(suggestion) {
+        return {
+            label: this.renderSuggestion(suggestion),
+            value: suggestion[this.valueParam],
+            basic: suggestion[this.labelParam]
+        }
+    }
+
+    filterResponse(data) {
+        this.inputUpdated();
+        const suggestions = [];
+        this.newResponse = true;
+        this.fullMatch = false;
+        if (data.length > 0) {
+            this.firstSuggestion = this.makeSuggestion(data[0]);
+        } else {
+            this.firstSuggestion = null;
+        }
+        for (const suggestion of data) {
+            if (this.selected.hasOwnProperty(
+                suggestion[this.valueParam].toString()
+            )) {
+                continue;
+            }
+            suggestions.push(this.makeSuggestion(suggestion));
+        }
+        return suggestions;
+    }
+
+    constructor(options) {
+        super(options.container);
+        this.textInput = this.container.find('.search-input');
+        this.formField = this.container.find(':input').first();
+        this.selected = {};
+        if (this.textInput.val()) {
+            this.selected[this.textInput.val()] = this.textInput.html();
+        }
+        this.serviceUrl = this.textInput.data('serviceUrl');
+        this.source = this.textInput.data('source');
+        this.searchParam = this.textInput.data('searchParam');
+        this.labelParam = this.textInput.data('labelParam') || this.searchParam;
+        this.valueParam = this.textInput.data('valueParam') || this.labelParam;
+        this.queryParams = this.textInput.data('queryParams') || {};
+        this.menuClass = this.textInput.data('menuClass') || '';
+
+        if (this.textInput.data('renderSuggestion')) {
+            this.renderSuggestion = new Function(
+                'obj',
+                this.textInput.data('renderSuggestion')
+            );
+        }
+
+        // blur the input when enter is pressed
+        this.textInput.keypress(function(e) {
+            if (e.which === 13) {
+                $(this).trigger('blur');
+            }
+        });
+
+        this.textInput.blur(() => {
+            if (this.fullMatch && this.firstSuggestion) {
+                this.add(this.firstSuggestion);
+            }
+        });
+
+        this.autocomplete = this.textInput.autocomplete({
+            delay: 250,
+            minLength: 0,
+            source: this.serviceUrl ? (request, response) => {
+                const data = this.queryParams;
+                data[this.searchParam] = request.term;
+                $.ajax({url: this.serviceUrl, data: data}).done(
+                    function(data) {
+                        response(this.filterResponse(data));
+                    }.bind(this)
+                ).fail(function(jqXHR) {console.log(jqXHR);});
+            }: (request, response) => {
+                const data = $.ui.autocomplete.filter(this.source, request.term);
+                response(
+                    this.filterResponse(
+                        data
+                    )
+                );
+            },
+            change: function(event, ui) {
+                this.formField.trigger('change');
+            }.bind(this),
+            select: function(event, ui) {
+                this.add(ui.item);
+                event.preventDefault();
+            }.bind(this),
+            focus: function(event, ui) {
+                this.textInput.html(ui.item.basic);
+                return false;
+            }.bind(this),
+
+        }).bind('focus', function() { $(this).autocomplete('search'); } );
+
+        const checkFullMatch = function(text, term) {
+            this.fullMatch |= text.toUpperCase() === term.toUpperCase();
+            if (!this.fullMatch) {
+                // special case for (text)
+                if (text.startsWith('(')) {
+                    text = text.substring(1);
+                }
+                if (text.endsWith(')')) {
+                    text = text.substring(0, text.length-1);
+                }
+                this.fullMatch |= text.toUpperCase() === term.toUpperCase();
+            }
+        }.bind(this);
+
+        const newResponse = function(newResponse=null) {
+            if (newResponse !== null) {
+                this.newResponse = newResponse;
+            }
+            return this.newResponse;
+        }.bind(this)
+
+        this.autocomplete.data('ui-autocomplete')._renderItem = function (ul, item) {
+            const label = $(`<div>${item.label}</div>`);
+            if (this.term) {
+                label.find('span.matchable').each((idx, child) => {
+                    if (newResponse()) {
+                        checkFullMatch($(child).text(), this.term);
+                    }
+                    $(child).html(
+                        String($(child).text()).replace(
+                            new RegExp(this.term, 'gi'),
+                        "<span class='autocomplete-match'>$&</span>")
+                    );
+                });
+            }
+            newResponse(false);
+            return $('<li></li>')
+                .data('item.ui-autocomplete', item)
+                .append(label)
+                .appendTo(ul);
+        };
+
+        if (this.menuClass) {
+            const menuClass = this.menuClass;
+            this.autocomplete.data('ui-autocomplete')._renderMenu = function (ul, items) {
+                const that = this;
+                $.each(items, function (index, item) {
+                    that._renderItemData(ul, item);
+                });
+                $(ul).addClass(menuClass);
+            }
+        }
+    }
+
+    add(item) {
+        this.remove(this.formField.val());
+        this.selected[item.value.toString()] = item.label;
+        this.formField.val(item.value.toString());
+        this.textInput.html(item.label);
+    }
+
+    remove(value) {
+        value = value.toString();
+        if (this.selected.hasOwnProperty(value)) {
+            delete this.selected[value];
+        }
+        this.formField.val('');
+        this.textInput.html('');
+    }
+
+    clear() {
+        for (const value of Object.keys(this.selected)) { this.remove(value, false); }
+    }
+
+    persist() {
+        this.persisted = this.selected;
+    }
+
+    revive() {
+        if (this.persisted) {
+            this.clear();
+            for (const [value, label] of Object.entries(this.persisted)) {
+                this.add({value: value, label: label});
+            }
+        }
+    }
+
+    changed() {}
+}
+
+export class AutoCompleteMultiple extends AutoComplete {
+    /**
+     * https://github.com/devbridge/jQuery-Autocomplete
+     *
+     * Expects the following data parameters on the auto complete container:
+     *
+     * data-service-url: (required) The url to fetch suggestions from via ajax
+     * data-search-param: (required) The url query parameter to use for the search string
+     * data-label-param: (optional) The property to use as the label (default: search-param)
+     * data-value-param: (optional) The property to use as the value (default: label-param)
+     * data-renderSuggestion: (optional) A javascript function body accepting an obj argument and
+     *  returning a string label to use for the suggestion.
+     *
+     *  When providing a render suggestion, text that is searchable should be
+     *  wrapped in <span class="matchable"></span>
+     */
+
+    display;
+
+    inputUpdated() { };
+
+    constructor(options) {
+        super(options);
+        this.display = this.container.find('.select-display');
+        this.selected = {};
+        this.formField.find('option:selected').each(
+            (idx, opt) => { this.selected[$(opt).val()] = $(opt).html(); }
+        );
+
+        this.display.find(`div.autocomplete-selection span:last-child`).click(function(event) {
+            this.remove($(event.target).closest('div.autocomplete-selection').data('value'));
+        }.bind(this));
+    }
+
+    add(item, trigger=true) {
+        this.textInput.html('');
+        this.selected[item.value.toString()] = item.label;
+        if (this.formField.find(`option[value="${item.value}"]`).length === 0) {
+            this.formField.prepend($(
+                `<option value="${item.value}" selected>${item.label}</option>`
+            ));
+        }
+        if (this.display.find(`div.autocomplete-selection[data-value="${item.value}"]`).length === 0) {
+            this.display.prepend(
+                `<div class="autocomplete-selection" data-value="${item.value}">${item.label}<span></span></div>`
+            );
+        }
+        this.display.find(`div.autocomplete-selection[data-value="${item.value}"] span:last-child`).click(function() {
+            this.remove(item.value);
+        }.bind(this));
+    }
+
+    remove(value, trigger=true) {
+        value = value.toString();
+        if (this.selected.hasOwnProperty(value)) {
+            delete this.selected[value];
+        }
+        this.formField.find(`option[value="${value}"]`).remove();
+        this.display.find(`div.autocomplete-selection[data-value="${value}"]`).remove();
+    }
+
+    changed() {
+        /**
+         * The underlying select has been updated - we must refresh the
+         * component to match it
+         */
+        const selected = this.formField.find('option:selected');
+        if (selected.length === 0) { return this.clear(); }
+        /* todo - only clear case handled above
+        selected.each(
+            (idx, opt) => { this.selected[$(opt).val()] = $(opt).html(); }
+        );
+         */
+    }
+}

slm/static/slm/js/enums.js

@@ -0,0 +1,322 @@
+if (typeof slm === 'undefined' || slm == null) { var slm = {}; }
+
+class LogEntryType {
+	
+	static SITE_PROPOSED = new LogEntryType(1, "SITE_PROPOSED", "Site Proposed", "slm-log-site-proposed");
+	static ADD = new LogEntryType(2, "ADD", "Add", "slm-log-add");
+	static UPDATE = new LogEntryType(3, "UPDATE", "Update", "slm-log-update");
+	static DELETE = new LogEntryType(4, "DELETE", "Delete", "slm-log-delete");
+	static PUBLISH = new LogEntryType(5, "PUBLISH", "Publish", "slm-log-publish");
+	static LOG_UPLOAD = new LogEntryType(6, "LOG_UPLOAD", "Log Upload", "slm-log-log-upload");
+	static IMAGE_UPLOAD = new LogEntryType(7, "IMAGE_UPLOAD", "Image Upload", "slm-log-image-upload");
+	static ATTACHMENT_UPLOAD = new LogEntryType(8, "ATTACHMENT_UPLOAD", "Attachment Upload", "slm-log-attachment-upload");
+	static IMAGE_PUBLISH = new LogEntryType(9, "IMAGE_PUBLISH", "Image Published", "slm-log-image-published");
+	static ATTACHMENT_PUBLISH = new LogEntryType(10, "ATTACHMENT_PUBLISH", "Attachment Published", "slm-log-attachment-published");
+	static IMAGE_UNPUBLISH = new LogEntryType(11, "IMAGE_UNPUBLISH", "Image Unpublished", "slm-log-image-unpublished");
+	static ATTACHMENT_UNPUBLISH = new LogEntryType(12, "ATTACHMENT_UNPUBLISH", "Attachment Unpublished", "slm-log-attachment-unpublished");
+	static IMAGE_DELETE = new LogEntryType(13, "IMAGE_DELETE", "Image Deleted", "slm-log-image-deleted");
+	static ATTACHMENT_DELETE = new LogEntryType(14, "ATTACHMENT_DELETE", "Attachment Deleted", "slm-log-attachment-deleted");
+	static REVERT = new LogEntryType(15, "REVERT", "Revert", "slm-log-revert");
+	
+	constructor (value, name, label, css) {
+		this.value = value;
+		this.name = name;
+		this.label = label;
+		this.css = css;
+	}
+	
+	static ciCompare(a, b) {
+		return typeof a === 'string' && typeof b === 'string' ? a.localeCompare(b, undefined, { sensitivity: 'accent' }) === 0 : a === b;
+	}
+	
+	toString() {
+		return this.label;
+	}
+	
+	static get(value) {
+		if (value instanceof this) {
+			return value;
+		}
+		
+		for (const en of this) {
+			if (en.value === value) {
+				return en;
+			}
+		}
+		for (const en of this) {
+			if (this.ciCompare(en.name, value)) {
+				return en;
+			}
+		}
+		return null;
+	}
+	
+	static [Symbol.iterator]() {
+		return [LogEntryType.SITE_PROPOSED, LogEntryType.ADD, LogEntryType.UPDATE, LogEntryType.DELETE, LogEntryType.PUBLISH, LogEntryType.LOG_UPLOAD, LogEntryType.IMAGE_UPLOAD, LogEntryType.ATTACHMENT_UPLOAD, LogEntryType.IMAGE_PUBLISH, LogEntryType.ATTACHMENT_PUBLISH, LogEntryType.IMAGE_UNPUBLISH, LogEntryType.ATTACHMENT_UNPUBLISH, LogEntryType.IMAGE_DELETE, LogEntryType.ATTACHMENT_DELETE, LogEntryType.REVERT][Symbol.iterator]();
+	}
+}
+class SiteLogStatus {
+	
+	static FORMER = new SiteLogStatus(1, "FORMER", "Former", "Site is no longer maintained and logs are not published.", "slm-status-former", "#3D4543");
+	static PROPOSED = new SiteLogStatus(2, "PROPOSED", "Proposed", "This is a new Site that has never been published.", "slm-status-proposed", "#913D88");
+	static UPDATED = new SiteLogStatus(3, "UPDATED", "Updated", "Site log or section has unpublished updates.", "slm-status-updated", "#0079AD");
+	static PUBLISHED = new SiteLogStatus(4, "PUBLISHED", "Published", "Site log or section is published with no unpublished changes.", "slm-status-published", "#0D820D");
+	static EMPTY = new SiteLogStatus(5, "EMPTY", "Empty", "Site log section is empty or deleted.", "slm-status-empty", "#D3D3D3");
+	static SUSPENDED = new SiteLogStatus(6, "SUSPENDED", "Suspended", "Site has been temporarily suspended and does not appear in public data.", "slm-status-suspended", "#E0041A");
+	
+	constructor (value, name, label, help, css, color) {
+		this.value = value;
+		this.name = name;
+		this.label = label;
+		this.help = help;
+		this.css = css;
+		this.color = color;
+	}
+	
+	static ciCompare(a, b) {
+		return typeof a === 'string' && typeof b === 'string' ? a.localeCompare(b, undefined, { sensitivity: 'accent' }) === 0 : a === b;
+	}
+	
+	toString() {
+		return this.label;
+	}
+	
+	static get(value) {
+		if (value instanceof this) {
+			return value;
+		}
+		
+		for (const en of this) {
+			if (en.value === value) {
+				return en;
+			}
+		}
+		for (const en of this) {
+			if (this.ciCompare(en.name, value)) {
+				return en;
+			}
+		}
+		return null;
+	}
+	
+	static [Symbol.iterator]() {
+		return [SiteLogStatus.FORMER, SiteLogStatus.PROPOSED, SiteLogStatus.UPDATED, SiteLogStatus.PUBLISHED, SiteLogStatus.EMPTY, SiteLogStatus.SUSPENDED][Symbol.iterator]();
+	}
+}
+class AlertLevel {
+	
+	static NOTICE = new AlertLevel(1, "NOTICE", "NOTICE", "slm-alert-notice", "#12CAF0");
+	static WARNING = new AlertLevel(2, "WARNING", "WARNING", "slm-alert-warning", "#E3AA00");
+	static ERROR = new AlertLevel(3, "ERROR", "ERROR", "slm-alert-error", "#DD3444");
+	
+	constructor (value, name, label, css, color) {
+		this.value = value;
+		this.name = name;
+		this.label = label;
+		this.css = css;
+		this.color = color;
+	}
+	
+	static ciCompare(a, b) {
+		return typeof a === 'string' && typeof b === 'string' ? a.localeCompare(b, undefined, { sensitivity: 'accent' }) === 0 : a === b;
+	}
+	
+	toString() {
+		return this.name;
+	}
+	
+	static get(value) {
+		if (value instanceof this) {
+			return value;
+		}
+		
+		for (const en of this) {
+			if (en.value === value) {
+				return en;
+			}
+		}
+		for (const en of this) {
+			if (this.ciCompare(en.name, value)) {
+				return en;
+			}
+		}
+		for (const en of this) {
+			if (en.label === value) {
+				return en;
+			}
+		}
+		return null;
+	}
+	
+	static [Symbol.iterator]() {
+		return [AlertLevel.NOTICE, AlertLevel.WARNING, AlertLevel.ERROR][Symbol.iterator]();
+	}
+}
+class SiteFileUploadStatus {
+	
+	static UNPUBLISHED = new SiteFileUploadStatus(1, "UNPUBLISHED", "Unpublished File", "The file is pending moderation before it will be made public.", "slm-upload-unpublished file", "#0079AD");
+	static PUBLISHED = new SiteFileUploadStatus(2, "PUBLISHED", "Published File", "The file is published and is publicly available as an attachment to the site.", "slm-upload-published file", "#0D820D");
+	static INVALID = new SiteFileUploadStatus(3, "INVALID", "Invalid Site Log", "The file did not pass validation.", "slm-upload-invalid site log", "#8b0000");
+	static WARNINGS = new SiteFileUploadStatus(4, "WARNINGS", "Warnings Site Log", "The file is valid but has some warnings.", "slm-upload-warnings site log", "#E3AA00");
+	static VALID = new SiteFileUploadStatus(5, "VALID", "Valid Site Log", "The file is valid.", "slm-upload-valid site log", "#0D820D");
+	
+	constructor (value, name, label, help, css, color) {
+		this.value = value;
+		this.name = name;
+		this.label = label;
+		this.help = help;
+		this.css = css;
+		this.color = color;
+	}
+	
+	static ciCompare(a, b) {
+		return typeof a === 'string' && typeof b === 'string' ? a.localeCompare(b, undefined, { sensitivity: 'accent' }) === 0 : a === b;
+	}
+	
+	toString() {
+		return this.label;
+	}
+	
+	static get(value) {
+		if (value instanceof this) {
+			return value;
+		}
+		
+		for (const en of this) {
+			if (en.value === value) {
+				return en;
+			}
+		}
+		for (const en of this) {
+			if (this.ciCompare(en.name, value)) {
+				return en;
+			}
+		}
+		return null;
+	}
+	
+	static [Symbol.iterator]() {
+		return [SiteFileUploadStatus.UNPUBLISHED, SiteFileUploadStatus.PUBLISHED, SiteFileUploadStatus.INVALID, SiteFileUploadStatus.WARNINGS, SiteFileUploadStatus.VALID][Symbol.iterator]();
+	}
+}
+class SiteLogFormat {
+	
+	static LEGACY = new SiteLogFormat(1, "LEGACY", "Legacy (ASCII)", "text/plain", "bi bi-file-text", "log", ["text", "txt", "legacy"]);
+	static GEODESY_ML = new SiteLogFormat(2, "GEODESY_ML", "GeodesyML", "application/xml", "bi bi-filetype-xml", "xml", ["xml"]);
+	static JSON = new SiteLogFormat(3, "JSON", "JSON", "application/json", "bi bi-filetype-json", "json", ["json", "js"]);
+	static ASCII_9CHAR = new SiteLogFormat(4, "ASCII_9CHAR", "ASCII (9-Char)", "text/plain", "bi bi-file-text", "log", ["text", "txt", "9char"]);
+	
+	constructor (value, name, label, mimetype, icon, ext, alts) {
+		this.value = value;
+		this.name = name;
+		this.label = label;
+		this.mimetype = mimetype;
+		this.icon = icon;
+		this.ext = ext;
+		this.alts = alts;
+	}
+	
+	static ciCompare(a, b) {
+		return typeof a === 'string' && typeof b === 'string' ? a.localeCompare(b, undefined, { sensitivity: 'accent' }) === 0 : a === b;
+	}
+	
+	toString() {
+		return this.label;
+	}
+	
+	static get(value) {
+		if (value instanceof this) {
+			return value;
+		}
+		
+		for (const en of this) {
+			if (en.value === value) {
+				return en;
+			}
+		}
+		for (const en of this) {
+			if (this.ciCompare(en.name, value)) {
+				return en;
+			}
+		}
+		return null;
+	}
+	
+	static [Symbol.iterator]() {
+		return [SiteLogFormat.LEGACY, SiteLogFormat.GEODESY_ML, SiteLogFormat.JSON, SiteLogFormat.ASCII_9CHAR][Symbol.iterator]();
+	}
+}
+class SLMFileType {
+	
+	static SITE_LOG = new SLMFileType(1, "SITE_LOG", "Site Log", "log");
+	static SITE_IMAGE = new SLMFileType(2, "SITE_IMAGE", "Site Image", "image");
+	static ATTACHMENT = new SLMFileType(3, "ATTACHMENT", "Attachment", "attachment");
+	
+	constructor (value, name, label, type) {
+		this.value = value;
+		this.name = name;
+		this.label = label;
+		this.type = type;
+	}
+	
+	static ciCompare(a, b) {
+		return typeof a === 'string' && typeof b === 'string' ? a.localeCompare(b, undefined, { sensitivity: 'accent' }) === 0 : a === b;
+	}
+	
+	toString() {
+		return this.label;
+	}
+	
+	static get(value) {
+		if (value instanceof this) {
+			return value;
+		}
+		
+		for (const en of this) {
+			if (en.value === value) {
+				return en;
+			}
+		}
+		for (const en of this) {
+			if (this.ciCompare(en.name, value)) {
+				return en;
+			}
+		}
+		for (const en of this) {
+			if (en.type === value) {
+				return en;
+			}
+		}
+		return null;
+	}
+	
+	static [Symbol.iterator]() {
+		return [SLMFileType.SITE_LOG, SLMFileType.SITE_IMAGE, SLMFileType.ATTACHMENT][Symbol.iterator]();
+	}
+}
+
+
+SiteLogStatus.prototype.set = function (child) {
+    if (
+        this === SiteLogStatus.PUBLISHED ||
+        this === SiteLogStatus.UPDATED ||
+        this === SiteLogStatus.EMPTY
+    ) {
+        return child;
+    }
+    return this.merge(child);
+};
+
+SiteLogStatus.prototype.merge = function (sibling) {
+    if (sibling !== null && sibling.value < this.value) {
+        return sibling;
+    }
+    return this;
+};
+
+slm.LogEntryType = LogEntryType;
+slm.SiteLogStatus = SiteLogStatus;
+slm.SiteFileUploadStatus = SiteFileUploadStatus;
+slm.AlertLevel = AlertLevel;
+slm.SiteLogFormat = SiteLogFormat;
+slm.SLMFileType = SLMFileType;