WindowedApp.js

From disqus.com, 1 Month ago, written in JavaScript, viewed 3 times. This paste is a reply to BaseApp.js from disqus.com - go back
URL https://pastebin.freepbx.org/view/69efdd1b/diff Embed
Viewing differences between BaseApp.js and WindowedApp.js
define('core/apps/BaseApp',['require','core/Events','core/utils/object/extend','core/utils/object/has','core/utils/uniqueId'],function define('core/apps/WindowedApp',['require','core/utils/object/extend','core/shared/urls','core/apps/BaseApp','core/host/kernel'],function (require) {
    'use strict';

    var Events = require('core/Events');
    
var extend = require('core/utils/object/extend');
    
require('core/utils/object/extend');

    
var has urls require('core/utils/object/has');
    
require('core/shared/urls');

    
var uniqueId BaseApp require('core/utils/uniqueId');

    
require('core/apps/BaseApp');

    var kernel = require('core/host/kernel');


    var doc = window.document;

    
// The base application class for Disqus apps. It any "windowed" app, that is a very "barebones"
    
using another "window"
    
// other than the window object on the page itself. Makes use of
    // Channel or Popup according to settings.
    // Having a "windowName" attribute defined on the settings object will
    // cause it to create a popup using that name, otherwise it will use the
    // Channel 
class having with an `extend` method on it for easy inheritance analogous to
    
expected container to put the iframe that Channel
    
// Backbone classes' extend method. The class covers uses. Covers the following:
    //    * Assigns a uid and and the passed settings to the instances
    //    * Registers and unregisters 
Expects the instance if or the derived class has
    
to have a "url" property
    
//      `register` and `unregister` *classmethods*
    
defining url for the application. It is assumed to be a protocol-
    //      relative URL.
    
//    * Supports If a `getFrameSettings` method is defined on the standard event interface from Backbone events:
    
instance or the
    
//      on, once, off, listenTo, stopListening, trigger
    
derived class it will be called right before creating the "window"
    //      passing the automatically built settings object. The method is
    //      expected to return a settings object. It can be the same object
    //      that was passed to it or a new one, but it SHOULD return a valid
    //      settings object to be passed to Channel or Popup constructor.
    
//    * Assigns `event name: handler` mappings Provides an `init` method as the main entry point. Calling this
    //      method will call trigger "state:INIT" event, then call `getFrame`
    //      to create the frame, which will call `getFrameSettings` as
    //      explained above. Assign the returned "frame" instance to `this.frame`
    //      proxy all events on the frame to the instance itself 
under `events` property using
the
    //      namespace "frame:" (eg frame:ready) and trigger "change:frame" after
    //      this.on. It traverses up to  Then it will load the root class and binds all events
    //      defined in all parent classes, in order. Thus an event handler 
frame using the `target` attribute on
    //      the parent class will always be executed before a handler defined
    //      for the same 
frame settings, trigger 'state:LOADED' event on the child class. THIS IS SUPER IMPORTANT!
    
when frame is loaded.
    
//    * Does all It will clean-up its frame when the "magic" explained above for one-time events listed
    //      under `onceEvents` property using `this.once`.
    
instance is destroyed.
    
//    * Detaches all event listeners It will do and stops listening to anything when
    //      destructor is called (destroy).
    var 
support everything BaseApp does and supports.
    var WindowedApp 
BaseApp.extend({
        // You need a name that matches a key in next.host.urls.apps for the
        // app to get proper URLs
        name: null,
        loaderVersion: null,
        frame: null,
        origin: urls.ensureHTTPSProtocol('{{ DISQUS_URL }}'),
        state: null,

        getUrl: 
function (settings) {
        this.uid = uniqueId('dsq-app');

        this.settings = settings || {};

        var parents = [];
        var parent = this.constructor.prototype;

        do 
(params, hashParams) {
            parents.unshift(parent);
            parent = parent.constructor.__super__;
        } while (parent);

        
// The event attaching order here is VERY important. It starts attaching
        // events from 
If applicable, add the top most parent loader version to the params
            if (this.loaderVersion) {
                hashParams = extend({
                    version: this.loaderVersion,
                }, hashParams);
            }

            // NOTE: urls.get already does this but without the HTTPS enforcement
            //       This is a minor hack 
and comes down to self which allows
        // proper inheritance: 
should be fixed once the handler on the base class HTTPS
            //       experiment 
is executed first
        for (var i = 0, length = parents.length; i < length; i++) 
finalized.

            return urls.ensureHTTPSProtocol(urls.get(this.name, params, hashParams));
        },

        getFrameSettings: function () 
{
            parent var frameSettings parents[i];
            
{
                target: this.getUrl(),
                origin: this.origin,
                uid: this.uid,
                sandbox: this.sandbox,
            };

            var settings = this.settings;
            
if (has(parent, 'events'))
(settings.windowName)
                frameSettings.windowName = settings.windowName;
            else
                frameSettings.container = settings.container || doc.body;

            if (settings.styles)
                frameSettings.styles = settings.styles;

            return frameSettings;
        },

        getFrame: function () {
            var frameSettings = this.getFrameSettings();
            var FrameConstructor = frameSettings.windowName ? kernel.Popup : kernel.Channel;
            return new FrameConstructor(frameSettings);
        },

        setState: function (state) {
            var constructor = this.constructor;

            if (!(state in constructor.states))
                return false;

            this.state = constructor.states[state];
            this.trigger('state:' + state);
        },

        init: function () {
            var self = this;
            var frame;

            self.frame = frame = this.getFrame();

            // We relay all events originating from the frame on our actual
            // instance by prefixing them with "frame:" which allows one to
            // listen to all "frame" events too even if the underlying frame
            // object is changed or not ready yet. This is almost the same
            // pattern we use in SessionModel to relay User events to session
            self.listenTo(frame, 'all', function (name, data) {
                self.trigger('frame:' + name, data, frame);
            });

            self.listenTo(frame, 'resize', function (data) {
                self.lastResizedHeight = data.height;
            });

            self.trigger('change:frame', frame);

            self.frame.load(function () {
                self.setState('LOADED');
            });

            self.setState('INIT');
        },

        destroy: function () {
            var frame = this.frame;
            if (frame) {
                this.on(parent.events, this);
            if (has(parent, 'onceEvents'))
stopListening(frame);
                frame.destroy();
            }

            this.setState('KILLED');
            this.frame = null;
            BaseApp.prototype.destroy.call(this);
        },

        events: {
            'frame:ready': function () {
                this.once(parent.onceEvents, this);
        }
    };

    extend(BaseApp.prototype, Events);

    BaseApp.prototype.destroy = function () 
setState('READY');
            },
        },
    }, 
{
        this.off();
        this.stopListening();
    };

    
states: {
            INIT: 0,  
// taken Iframe has been created but received no further messages
            LOADED: 1,  // Received the iframe's load event
            READY: 2,  // Received a message 
from Backbone extend helper
    BaseApp.extend = function (protoProps, staticProps) {
        var parent = this; // eslint-disable-line consistent-this
        var child;

        // The constructor function for 
the new subclass is either defined by you
        // (the "constructor" property in your `extend` definition), or defaulted
        // by us to simply call 
iframe client indicating the parent's constructor.
        if (protoProps && has(protoProps, 'constructor'))
            child = protoProps.constructor;
        else
            child = function () { 
code is ready
            RUNNING: 3,  // Iframe is operational and visible
            KILLED: 4,
        },
    });

    
return parent.apply(this, arguments); };

        // Add static properties to the constructor function, if supplied.
        extend(child, parent, staticProps);

        // Set the prototype chain to inherit from `parent`, without calling
        // `parent`'s constructor function.
        var Surrogate = function () { this.constructor = child; };
        Surrogate.prototype = parent.prototype;
        child.prototype = new Surrogate();

        // Add prototype properties (instance properties) to the subclass,
        // if supplied.
        if (protoProps) extend(child.prototype, protoProps);

        // Set a convenience property in case the parent's prototype is needed
        // later.
        child.__super__ = parent.prototype;

        return child;
    };

    return BaseApp;
});

// https://c.
WindowedApp;
});


//https://c.
disquscdn.com/next/next-core/core/apps/BaseApp.com/next/next-core/core/apps/WindowedApp.js

Replies to WindowedApp.js rss

Title Name Language When
exploreModuleConstants.js disqus.com javascript 1 Month ago.

Reply to "WindowedApp.js"

Here you can reply to the paste above