hoodcms 5.0.7 → 5.0.8

package/dist/js/core/Handlers.js

@@ -0,0 +1,160 @@
+export class Handlers {
+    constructor() {
+    }
+    /**
+     * Initialise all default Hood CMS handlers.
+     */
+    initDefaultHandlers() {
+        this.checkboxToCsvInput();
+        this.iconSelector();
+        this.initSelectValues();
+        this.scrollHandlers();
+        this.selectText();
+        this.setValueOnClick();
+        this.submitOnChange();
+    }
+    /**
+     * Sets values of any selects that have the value set in data-selected, useful for
+     */
+    initSelectValues(tag = 'body') {
+        $(tag).find('select[data-selected]').each(this.initSelectValuesHandler);
+    }
+    initSelectValuesHandler(index, element) {
+        let sel = $(this).data('selected');
+        if (sel !== 'undefined' && sel !== '') {
+            let selected = String(sel);
+            $(this).val(selected);
+        }
+    }
+    /**
+     * Sets up any Hood Icon selector fields, requires the correct HTML setup.
+     */
+    iconSelector(tag = 'body') {
+        $(tag).find('[data-hood-icon]').each(this.iconSelectorHandler);
+    }
+    iconSelectorHandler(index, element) {
+        let $tag = $(this);
+        let input = $tag.find('input[data-hood-icon-input]');
+        let display = $tag.find('[data-hood-icon-display]');
+        let collapse = $tag.find('.collapse');
+        $tag.find('[data-hood-icon-key][data-hood-icon-value]').on('click', function () {
+            $tag.find('[data-hood-icon-key][data-hood-icon-value]').removeClass('active');
+            $(this).addClass('active');
+            let key = $(this).data('hoodIconKey');
+            let value = $(this).data('hoodIconValue');
+            $(this);
+            display.html(value);
+            input.val(key);
+            if (collapse) {
+                collapse.removeClass('show');
+            }
+        });
+    }
+    /**
+     * Submits the form when input is changed, mark inputs with .submit-on-change class.
+     */
+    selectText(tag = 'body') {
+        $(tag).on('click', '.select-text', this.selectTextHandler);
+    }
+    selectTextHandler() {
+        let $this = $(this);
+        $this.select();
+        // Work around Chrome's little problem
+        $this.mouseup(function () {
+            // Prevent further mouseup intervention
+            $this.unbind("mouseup");
+            return false;
+        });
+    }
+    /**
+     * Attaches handlers for default scrolling functions, scroll to top, scroll to target (with header.header offset calculated)
+     * and scroll to target direct (with no calculated offset).
+     */
+    scrollHandlers(tag = 'body') {
+        $(tag).on('click', '.scroll-top, .scroll-to-top', this.scrollTop);
+        $(tag).on('click', '.scroll-target, .scroll-to-target', this.scrollTarget);
+        $(tag).on('click', '.scroll-target-direct, .scroll-to-target-direct', this.scrollTargetDirect);
+    }
+    scrollTop(e) {
+        if (e)
+            e.preventDefault();
+        $('html, body').animate({ scrollTop: 0 }, 800);
+        return false;
+    }
+    scrollTarget(e) {
+        if (e)
+            e.preventDefault();
+        let url = $(this).attr('href').split('#')[0];
+        if (url !== window.location.pathname && url !== "") {
+            return;
+        }
+        let target = this.hash;
+        let $target = $(target);
+        let $header = $('header.header');
+        let headerOffset = 0;
+        if ($header) {
+            headerOffset = $header.height();
+        }
+        if ($(this).data('offset'))
+            $('html, body').stop().animate({
+                'scrollTop': $target.offset().top - $(this).data('offset')
+            }, 900, 'swing');
+        else
+            $('html, body').stop().animate({
+                'scrollTop': $target.offset().top - headerOffset
+            }, 900, 'swing');
+    }
+    scrollTargetDirect() {
+        let scrollTop = $('body').scrollTop();
+        let top = $($(this).attr('href')).offset().top;
+        $('html, body').animate({
+            scrollTop: top
+        }, Math.abs(top - scrollTop));
+        return false;
+    }
+    /**
+    * Compiles any selected checkboxes with matching data-hood-csv-input tags,
+    * then saves the CSV list of the values to the input given in the tag.
+    */
+    checkboxToCsvInput(tag = 'body') {
+        $(tag).on('change', 'input[type=checkbox][data-hood-csv-input]', this.checkboxToCsvInputHandler);
+    }
+    checkboxToCsvInputHandler(e) {
+        if (e)
+            e.preventDefault();
+        // when i change - create an array, with any other checked of the same data-input checkboxes. and add to the data-input referenced tag.
+        let items = new Array();
+        $('input[data-hood-csv-input="' + $(this).data('hoodCsvInput') + '"]').each(function () {
+            if ($(this).is(":checked"))
+                items.push($(this).val());
+        });
+        let id = '#' + $(this).data('input');
+        let vals = JSON.stringify(items);
+        $(id).val(vals);
+    }
+    /**
+    * Submits the form when input is changed, mark inputs with .submit-on-change class.
+    */
+    submitOnChange(tag = 'body') {
+        $(tag).on('change', '.submit-on-change', this.submitOnChangeHandler);
+    }
+    submitOnChangeHandler(e) {
+        if (e)
+            e.preventDefault();
+        $(this).parents('form').submit();
+    }
+    /**
+    * Sets the value of the input [data-target] when clicked to the value in [data-value]
+    */
+    setValueOnClick(tag = 'body') {
+        $(tag).on('click', '.click-select[data-target][data-value]', this.setValueOnClickHandler);
+    }
+    setValueOnClickHandler() {
+        let $this = $(this);
+        let targetId = '#' + $this.data('target');
+        $(targetId).val($this.data('value'));
+        $(targetId).trigger('change');
+        $('.click-select.clean[data-target="' + $this.data('target') + '"]').each(function () { $(this).removeClass('active'); });
+        $('.click-select.clean[data-target="' + $this.data('target') + '"][data-value="' + $this.data('value') + '"]').each(function () { $(this).addClass('active'); });
+    }
+}

package/dist/js/core/HoodApi.d.ts

@@ -0,0 +1,25 @@
+import { Alerts } from "./Alerts";
+import { ColorPickers } from "./ColorPicker";
+import { Editors } from "./Editors";
+import { Handlers } from "./Handlers";
+import { Uploader } from "./Uploader";
+declare global {
+    interface Hood {
+        alerts: Alerts;
+        uploader: Uploader;
+        handlers: Handlers;
+    }
+    interface Window {
+        hood: Hood;
+    }
+}
+export declare class HoodApi implements Hood {
+    alerts: Alerts;
+    uploader: Uploader;
+    handlers: Handlers;
+    editors: Editors;
+    colorPickers: ColorPickers;
+    private mediaModal;
+    constructor();
+    setupLoaders(): void;
+}

package/dist/js/core/HoodApi.js

@@ -0,0 +1,22 @@
+import { Alerts } from "./Alerts";
+import { ColorPickers } from "./ColorPicker";
+import { Editors } from "./Editors";
+import { Handlers } from "./Handlers";
+import { MediaModal } from "./Media";
+import { Uploader } from "./Uploader";
+export class HoodApi {
+    constructor() {
+        this.alerts = new Alerts();
+        this.uploader = new Uploader();
+        this.handlers = new Handlers();
+        this.editors = new Editors();
+        this.colorPickers = new ColorPickers();
+        this.mediaModal = new MediaModal();
+        // Global Handlers
+        this.setupLoaders();
+    }
+    setupLoaders() {
+        $('body').on('loader-show', function () { Alerts.success("Showing loader..."); });
+        $('body').on('loader-hide', function () { Alerts.error("Hiding loader..."); });
+    }
+}

package/dist/js/core/Inline.d.ts

@@ -0,0 +1,27 @@
+import { Response } from "./Response";
+export interface InlineOptions {
+    /**
+     * Called before the data is fetched.
+     */
+    onLoad?: (sender?: HTMLElement) => void;
+    /**
+     * Called before the fetched HTML is rendered to the list. Must return the data back to datalist to render.
+     */
+    onRender?: (html: string, sender?: HTMLElement) => string;
+    /**
+     * Called when loading and rendering is complete.
+     */
+    onComplete?: (html: string, sender?: HTMLElement) => void;
+    /**
+     * Called when an error occurs.
+     */
+    onError?: (jqXHR: any, textStatus: any, errorThrown: any) => void;
+}
+export declare class Inline {
+    static load(tag: HTMLElement, options: InlineOptions): void;
+    static task(url: string, sender: HTMLElement, complete?: (data: Response, sender?: HTMLElement) => void, error?: (jqXHR: any, textStatus: any, errorThrown: any) => void): void;
+    static post(url: string, sender: HTMLElement, complete?: (data: Response, sender?: HTMLElement) => void, error?: (jqXHR: any, textStatus: any, errorThrown: any) => void): void;
+    static handleError(xhr: {
+        status: string | number;
+    }, textStatus: any, errorThrown: any): void;
+}

package/dist/js/core/Inline.js

@@ -0,0 +1,63 @@
+import { Alerts } from "./Alerts";
+export class Inline {
+    static load(tag, options) {
+        var _a;
+        let $tag = $(tag);
+        $tag.addClass('loading');
+        if (options.onLoad) {
+            options.onLoad(tag);
+        }
+        let url = $tag.data('url');
+        $.get(url, function (data) {
+            if (options.onRender) {
+                data = options.onRender(data, tag);
+            }
+            $tag.html(data);
+            $tag.removeClass('loading');
+            if (options.onComplete) {
+                options.onComplete(data, tag);
+            }
+        })
+            .fail((_a = options.onError) !== null && _a !== void 0 ? _a : Inline.handleError);
+    }
+    static task(url, sender, complete = null, error = null) {
+        if (sender) {
+            sender.classList.add('loading');
+        }
+        $.get(url, function (response) {
+            if (sender) {
+                sender.classList.remove('loading');
+            }
+            if (complete) {
+                complete(response, sender);
+            }
+        })
+            .fail(error !== null && error !== void 0 ? error : Inline.handleError);
+    }
+    static post(url, sender, complete = null, error = null) {
+        if (sender) {
+            sender.classList.add('loading');
+        }
+        $.post(url, function (response) {
+            if (sender) {
+                sender.classList.remove('loading');
+            }
+            if (complete) {
+                complete(response, sender);
+            }
+        })
+            .fail(error !== null && error !== void 0 ? error : Inline.handleError);
+    }
+    static handleError(xhr, textStatus, errorThrown) {
+        if (xhr.status === 500) {
+            Alerts.error("There was an error processing the content, please contact an administrator if this continues.", "Error " + xhr.status, 10000);
+        }
+        else if (xhr.status === 404) {
+            Alerts.error("The content could not be found.", "Error " + xhr.status, 10000);
+        }
+        else if (xhr.status === 401) {
+            Alerts.error("You are not allowed to view this resource, are you logged in correctly?", "Error " + xhr.status, 10000);
+            window.location = window.location;
+        }
+    }
+}

package/dist/js/core/Loader.d.ts

@@ -0,0 +1,5 @@
+export declare class Loader {
+    constructor();
+    static show(): void;
+    static hide(): void;
+}

package/dist/js/core/Loader.js

@@ -0,0 +1,13 @@
+export class Loader {
+    constructor() {
+        new CustomEvent('loader-show');
+        new CustomEvent('loader-hide');
+    }
+    static show() {
+        $('body').trigger('loader-show');
+    }
+    static hide() {
+        $('body').trigger('loader-hide');
+    }
+}
+new Loader();

package/dist/js/core/Media.d.ts

@@ -0,0 +1,113 @@
+/// <reference types="jquery" />
+import { DataList } from "./DataList";
+import { ModalController } from "./Modal";
+import { Editor } from "tinymce";
+export declare interface MediaObject {
+    id: number;
+    fileSize: number;
+    fileType: string;
+    filename: string;
+    blobReference: string;
+    createdOn: Date;
+    url: string;
+    thumbUrl: string;
+    smallUrl: string;
+    mediumUrl: string;
+    largeUrl: string;
+    uniqueId: string;
+    genericFileType: 'Image' | 'PDF' | 'Word' | 'Photoshop' | 'Excel' | 'PowerPoint' | 'Directory' | 'Audio' | 'Video' | 'Unknown';
+    downloadUrl: string;
+    downloadUrlHttps: string;
+    icon: string;
+    formattedSize: string;
+    path: string;
+}
+export interface MediaOptions {
+    /**
+    * Action for the media service to take when a media item is clicked.
+    */
+    action: 'insert' | 'attach' | 'select' | string;
+    /**
+     * Selector for any elements that require a refresh of background-image or src (if applicable).
+     */
+    refresh?: string;
+    /**
+     * Insert/Select Only: Input field to insert image url to.
+     */
+    size?: string;
+    /**
+     * Select/Gallery Only: Input field to insert image url to.
+     */
+    target?: string;
+    /**
+     * Insert Only: Input field to insert image url to.
+     */
+    targetEditor?: Editor;
+    /**
+     * Attach Only: Post url to send the selected media id to when clicked. Must accept mediaId as a parameter.
+     */
+    url?: string;
+    /**
+     * Called before the action is carried out.
+     */
+    beforeAction?: (sender?: HTMLElement) => void;
+    /**
+     * Called when the action is complete.
+     */
+    onAction?: (mediaObject: MediaObject, sender?: HTMLElement) => void;
+    /**
+     * Called before the media list is is fetched.
+     */
+    onListLoad?: (sender?: HTMLElement) => void;
+    /**
+     * Called before the fetched HTML is rendered to the media list. Must return the data back to datalist to render.
+     */
+    onListRender?: (html: string, sender?: HTMLElement) => string;
+    /**
+     * Called when media list loading and rendering is complete.
+     */
+    onListComplete?: (html: string, sender?: HTMLElement) => void;
+    /**
+     * Called when an error occurs.
+     */
+    onError?: (jqXHR: any, textStatus: any, errorThrown: any) => void;
+}
+export declare class MediaService {
+    media: DataList;
+    element: HTMLElement;
+    options: MediaOptions;
+    currentBlade: ModalController;
+    progress: JQuery<HTMLElement>;
+    progressText: JQuery<HTMLElement>;
+    uploadButton: HTMLElement;
+    uploader: HTMLElement;
+    progressArea: HTMLElement;
+    dropzone: any;
+    galleryInitialised: boolean;
+    constructor(element: HTMLElement, options: MediaOptions);
+    initUploader(): void;
+    createDirectory(this: MediaService, e: JQuery.ClickEvent): void;
+    deleteDirectory(this: MediaService, e: JQuery.ClickEvent): void;
+    uploadUrl(): string;
+    action(this: MediaService, e: JQuery.ClickEvent): void;
+    show(this: MediaService, mediaObject: MediaObject, sender: JQuery.ClickEvent): void;
+    select(this: MediaService, mediaObject: MediaObject, e: JQuery.ClickEvent): void;
+    insert(this: MediaService, mediaObject: MediaObject, e: JQuery.ClickEvent): void;
+    attach(this: MediaService, mediaObject: MediaObject, e: JQuery.ClickEvent): void;
+    selectedMedia: MediaObject[];
+    galleryClick(this: MediaService, mediaObject: MediaObject, e: JQuery.ClickEvent): void;
+    galleryAdd(this: MediaService, e: JQuery.ClickEvent): void;
+    isMediaSelected(mediaObject: MediaObject): boolean;
+    static refresh(media: MediaObject, refresh: string): void;
+    delete(this: MediaService, e: JQuery.ClickEvent): void;
+}
+export declare class MediaModal {
+    modal: ModalController;
+    list: HTMLElement;
+    service: MediaService;
+    element: HTMLElement;
+    constructor();
+    initGallery(this: MediaModal, index: number, element: HTMLElement): void;
+    load(this: MediaModal, e: JQuery.ClickEvent): void;
+    clear(this: MediaModal, e: JQuery.ClickEvent): void;
+}