discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-glimmer/lib/component-managers/custom.js

@@ -1,145 +0,0 @@
-import { assert } from '@ember/debug';
-import { RootReference } from '../utils/references';
-import AbstractComponentManager from './abstract';
-const CAPABILITIES = {
-    dynamicLayout: false,
-    dynamicTag: false,
-    prepareArgs: false,
-    createArgs: true,
-    attributeHook: false,
-    elementHook: false,
-    createCaller: false,
-    dynamicScope: true,
-    updateHook: true,
-    createInstance: true,
-};
-export function capabilities(managerAPI, options = {}) {
-    assert('Invalid component manager compatibility specified', managerAPI === '3.4');
-    return {
-        asyncLifeCycleCallbacks: !!options.asyncLifecycleCallbacks,
-        destructor: !!options.destructor,
-    };
-}
-export function hasAsyncLifeCycleCallbacks(delegate) {
-    return delegate.capabilities.asyncLifeCycleCallbacks;
-}
-export function hasDestructors(delegate) {
-    return delegate.capabilities.destructor;
-}
-function valueForCapturedArgs(args) {
-    return {
-        named: args.named.value(),
-        positional: args.positional.value(),
-    };
-}
-/**
-  The CustomComponentManager allows addons to provide custom component
-  implementations that integrate seamlessly into Ember. This is accomplished
-  through a delegate, registered with the custom component manager, which
-  implements a set of hooks that determine component behavior.
-
-  To create a custom component manager, instantiate a new CustomComponentManager
-  class and pass the delegate as the first argument:
-
-  ```js
-  let manager = new CustomComponentManager({
-    // ...delegate implementation...
-  });
-  ```
-
-  ## Delegate Hooks
-
-  Throughout the lifecycle of a component, the component manager will invoke
-  delegate hooks that are responsible for surfacing those lifecycle changes to
-  the end developer.
-
-  * `create()` - invoked when a new instance of a component should be created
-  * `update()` - invoked when the arguments passed to a component change
-  * `getContext()` - returns the object that should be
-*/
-export default class CustomComponentManager extends AbstractComponentManager {
-    create(_env, definition, args) {
-        const { delegate } = definition;
-        const capturedArgs = args.capture();
-        let invocationArgs = valueForCapturedArgs(capturedArgs);
-        const component = delegate.createComponent(definition.ComponentClass.class, invocationArgs);
-        return new CustomComponentState(delegate, component, capturedArgs);
-    }
-    update({ delegate, component, args }) {
-        delegate.updateComponent(component, valueForCapturedArgs(args));
-    }
-    didCreate({ delegate, component }) {
-        if (hasAsyncLifeCycleCallbacks(delegate)) {
-            delegate.didCreateComponent(component);
-        }
-    }
-    didUpdate({ delegate, component }) {
-        if (hasAsyncLifeCycleCallbacks(delegate)) {
-            delegate.didUpdateComponent(component);
-        }
-    }
-    getContext({ delegate, component }) {
-        delegate.getContext(component);
-    }
-    getSelf({ delegate, component, }) {
-        const context = delegate.getContext(component);
-        return new RootReference(context);
-    }
-    getDestructor(state) {
-        if (hasDestructors(state.delegate)) {
-            return state;
-        }
-        else {
-            return null;
-        }
-    }
-    getCapabilities() {
-        return CAPABILITIES;
-    }
-    getTag({ args }) {
-        return args.tag;
-    }
-    didRenderLayout() { }
-    getLayout(state) {
-        return {
-            handle: state.template.asLayout().compile(),
-            symbolTable: state.symbolTable,
-        };
-    }
-}
-const CUSTOM_COMPONENT_MANAGER = new CustomComponentManager();
-/**
- * Stores internal state about a component instance after it's been created.
- */
-export class CustomComponentState {
-    constructor(delegate, component, args) {
-        this.delegate = delegate;
-        this.component = component;
-        this.args = args;
-    }
-    destroy() {
-        const { delegate, component } = this;
-        if (hasDestructors(delegate)) {
-            delegate.destroyComponent(component);
-        }
-    }
-}
-export class CustomManagerDefinition {
-    constructor(name, ComponentClass, delegate, template) {
-        this.name = name;
-        this.ComponentClass = ComponentClass;
-        this.delegate = delegate;
-        this.template = template;
-        this.manager = CUSTOM_COMPONENT_MANAGER;
-        const layout = template.asLayout();
-        const symbolTable = layout.symbolTable;
-        this.symbolTable = symbolTable;
-        this.state = {
-            name,
-            ComponentClass,
-            template,
-            symbolTable,
-            delegate,
-        };
-    }
-}

data/dist/es/ember-glimmer/lib/component-managers/definition-state.js

@@ -1 +0,0 @@
-;

data/dist/es/ember-glimmer/lib/component-managers/mount.js

@@ -1,103 +0,0 @@
-import { DEBUG } from '@glimmer/env';
-import { CONSTANT_TAG } from '@glimmer/reference';
-import { EMBER_ENGINES_MOUNT_PARAMS } from '@ember/canary-features';
-import { generateControllerFactory } from 'ember-routing';
-import { RootReference } from '../utils/references';
-import AbstractManager from './abstract';
-const CAPABILITIES = {
-    dynamicLayout: true,
-    dynamicTag: false,
-    prepareArgs: false,
-    createArgs: false,
-    attributeHook: false,
-    elementHook: false,
-    createCaller: true,
-    dynamicScope: true,
-    updateHook: true,
-    createInstance: true,
-};
-class MountManager extends AbstractManager {
-    getDynamicLayout(state, _) {
-        let template = state.engine.lookup('template:application');
-        let layout = template.asLayout();
-        return {
-            handle: layout.compile(),
-            symbolTable: layout.symbolTable,
-        };
-    }
-    getCapabilities() {
-        return CAPABILITIES;
-    }
-    create(environment, state) {
-        if (DEBUG) {
-            this._pushEngineToDebugStack(`engine:${state.name}`, environment);
-        }
-        // TODO
-        // mount is a runtime helper, this shouldn't use dynamic layout
-        // we should resolve the engine app template in the helper
-        // it also should use the owner that looked up the mount helper.
-        let engine = environment.owner.buildChildEngineInstance(state.name);
-        engine.boot();
-        let applicationFactory = engine.factoryFor(`controller:application`);
-        let controllerFactory = applicationFactory || generateControllerFactory(engine, 'application');
-        let controller;
-        let self;
-        let bucket;
-        let tag;
-        if (EMBER_ENGINES_MOUNT_PARAMS) {
-            let modelRef = state.modelRef;
-            if (modelRef === undefined) {
-                controller = controllerFactory.create();
-                self = new RootReference(controller);
-                tag = CONSTANT_TAG;
-                bucket = { engine, controller, self, tag };
-            }
-            else {
-                let model = modelRef.value();
-                let modelRev = modelRef.tag.value();
-                controller = controllerFactory.create({ model });
-                self = new RootReference(controller);
-                tag = modelRef.tag;
-                bucket = { engine, controller, self, tag, modelRef, modelRev };
-            }
-        }
-        else {
-            controller = controllerFactory.create();
-            self = new RootReference(controller);
-            tag = CONSTANT_TAG;
-            bucket = { engine, controller, self, tag };
-        }
-        return bucket;
-    }
-    getSelf({ self }) {
-        return self;
-    }
-    getTag(state) {
-        return state.tag;
-    }
-    getDestructor({ engine }) {
-        return engine;
-    }
-    didRenderLayout() {
-        if (DEBUG) {
-            this.debugStack.pop();
-        }
-    }
-    update(bucket) {
-        if (EMBER_ENGINES_MOUNT_PARAMS) {
-            let { controller, modelRef, modelRev } = bucket;
-            if (!modelRef.tag.validate(modelRev)) {
-                let model = modelRef.value();
-                bucket.modelRev = modelRef.tag.value();
-                controller.set('model', model);
-            }
-        }
-    }
-}
-const MOUNT_MANAGER = new MountManager();
-export class MountDefinition {
-    constructor(name, modelRef) {
-        this.manager = MOUNT_MANAGER;
-        this.state = { name, modelRef };
-    }
-}

data/dist/es/ember-glimmer/lib/component-managers/outlet.js

@@ -1,114 +0,0 @@
-import { _instrumentStart } from '@ember/instrumentation';
-import { assign } from '@ember/polyfills';
-import { DEBUG } from '@glimmer/env';
-import { CONSTANT_TAG } from '@glimmer/reference';
-import { UNDEFINED_REFERENCE, } from '@glimmer/runtime';
-import { ENV } from 'ember-environment';
-import { guidFor } from 'ember-utils';
-import { RootReference } from '../utils/references';
-import AbstractManager from './abstract';
-function instrumentationPayload(def) {
-    return { object: `${def.name}:${def.outlet}` };
-}
-const CAPABILITIES = {
-    dynamicLayout: false,
-    dynamicTag: false,
-    prepareArgs: false,
-    createArgs: false,
-    attributeHook: false,
-    elementHook: false,
-    createCaller: true,
-    dynamicScope: true,
-    updateHook: true,
-    createInstance: true,
-};
-class OutletComponentManager extends AbstractManager {
-    create(environment, definition, _args, dynamicScope) {
-        if (DEBUG) {
-            this._pushToDebugStack(`template:${definition.template.referrer.moduleName}`, environment);
-        }
-        dynamicScope.outletState = definition.ref;
-        // this is only used for render helper which is legacy
-        if (dynamicScope.rootOutletState === undefined) {
-            dynamicScope.rootOutletState = dynamicScope.outletState;
-        }
-        let controller = definition.controller;
-        let self = controller === undefined ? UNDEFINED_REFERENCE : new RootReference(controller);
-        return {
-            self,
-            finalize: _instrumentStart('render.outlet', instrumentationPayload, definition),
-        };
-    }
-    layoutFor(_state, _component, _env) {
-        throw new Error('Method not implemented.');
-    }
-    getLayout({ template }, _resolver) {
-        // The router has already resolved the template
-        const layout = template.asLayout();
-        return {
-            handle: layout.compile(),
-            symbolTable: layout.symbolTable,
-        };
-    }
-    getCapabilities() {
-        return CAPABILITIES;
-    }
-    getSelf({ self }) {
-        return self;
-    }
-    getTag() {
-        // an outlet has no hooks
-        return CONSTANT_TAG;
-    }
-    didRenderLayout(state) {
-        state.finalize();
-        if (DEBUG) {
-            this.debugStack.pop();
-        }
-    }
-    getDestructor() {
-        return null;
-    }
-}
-const OUTLET_MANAGER = new OutletComponentManager();
-export class OutletComponentDefinition {
-    constructor(state, manager = OUTLET_MANAGER) {
-        this.state = state;
-        this.manager = manager;
-    }
-}
-export function createRootOutlet(outletView) {
-    if (ENV._APPLICATION_TEMPLATE_WRAPPER) {
-        const WRAPPED_CAPABILITIES = assign({}, CAPABILITIES, {
-            dynamicTag: true,
-            elementHook: true,
-        });
-        const WrappedOutletComponentManager = class extends OutletComponentManager {
-            getTagName(_component) {
-                return 'div';
-            }
-            getLayout(state) {
-                // The router has already resolved the template
-                const template = state.template;
-                const layout = template.asWrappedLayout();
-                return {
-                    handle: layout.compile(),
-                    symbolTable: layout.symbolTable,
-                };
-            }
-            getCapabilities() {
-                return WRAPPED_CAPABILITIES;
-            }
-            didCreateElement(component, element, _operations) {
-                // to add GUID id and class
-                element.setAttribute('class', 'ember-view');
-                element.setAttribute('id', guidFor(component));
-            }
-        };
-        const WRAPPED_OUTLET_MANAGER = new WrappedOutletComponentManager();
-        return new OutletComponentDefinition(outletView.state, WRAPPED_OUTLET_MANAGER);
-    }
-    else {
-        return new OutletComponentDefinition(outletView.state);
-    }
-}

data/dist/es/ember-glimmer/lib/component-managers/render.js

@@ -1,112 +0,0 @@
-import { RENDER_HELPER } from '@ember/deprecated-features';
-import { CONSTANT_TAG } from '@glimmer/reference';
-import { DEBUG } from '@glimmer/env';
-import { generateController, generateControllerFactory } from 'ember-routing';
-import { OrphanedOutletReference } from '../utils/outlet';
-import { RootReference } from '../utils/references';
-import AbstractManager from './abstract';
-let NON_SINGLETON_RENDER_MANAGER;
-let SINGLETON_RENDER_MANAGER;
-let RenderDefinition;
-if (RENDER_HELPER) {
-    class AbstractRenderManager extends AbstractManager {
-        create(env, definition, args, dynamicScope) {
-            let { name } = definition;
-            if (DEBUG) {
-                this._pushToDebugStack(`controller:${name} (with the render helper)`, env);
-            }
-            if (dynamicScope.rootOutletState) {
-                dynamicScope.outletState = new OrphanedOutletReference(dynamicScope.rootOutletState, name);
-            }
-            return this.createRenderState(args, env.owner, name);
-        }
-        getLayout({ template }) {
-            const layout = template.asLayout();
-            return {
-                handle: layout.compile(),
-                symbolTable: layout.symbolTable,
-            };
-        }
-        getSelf({ controller }) {
-            return new RootReference(controller);
-        }
-    }
-    if (DEBUG) {
-        AbstractRenderManager.prototype.didRenderLayout = function () {
-            this.debugStack.pop();
-        };
-    }
-    const CAPABILITIES = {
-        dynamicLayout: false,
-        dynamicTag: false,
-        prepareArgs: false,
-        createArgs: false,
-        attributeHook: false,
-        elementHook: false,
-        createCaller: true,
-        dynamicScope: true,
-        updateHook: true,
-        createInstance: true,
-    };
-    class SingletonRenderManager extends AbstractRenderManager {
-        createRenderState(_args, owner, name) {
-            let controller = owner.lookup(`controller:${name}`) || generateController(owner, name);
-            return { controller };
-        }
-        getCapabilities(_) {
-            return CAPABILITIES;
-        }
-        getTag() {
-            // todo this should be the tag of the state args
-            return CONSTANT_TAG;
-        }
-        getDestructor() {
-            return null;
-        }
-    }
-    SINGLETON_RENDER_MANAGER = new SingletonRenderManager();
-    const NONSINGLETON_CAPABILITIES = {
-        dynamicLayout: false,
-        dynamicTag: false,
-        prepareArgs: false,
-        createArgs: true,
-        attributeHook: false,
-        elementHook: false,
-        dynamicScope: true,
-        createCaller: false,
-        updateHook: true,
-        createInstance: true,
-    };
-    class NonSingletonRenderManager extends AbstractRenderManager {
-        createRenderState(args, owner, name) {
-            let model = args.positional.at(1);
-            let factory = owner.factoryFor(`controller:${name}`) ||
-                generateControllerFactory(owner, `controller:${name}`);
-            let controller = factory.create({ model: model.value() });
-            return { controller, model };
-        }
-        update({ controller, model }) {
-            controller.set('model', model.value());
-        }
-        getCapabilities(_) {
-            return NONSINGLETON_CAPABILITIES;
-        }
-        getTag({ model }) {
-            return model.tag;
-        }
-        getDestructor({ controller }) {
-            return controller;
-        }
-    }
-    NON_SINGLETON_RENDER_MANAGER = new NonSingletonRenderManager();
-    RenderDefinition = class RenderDefinition {
-        constructor(name, template, manager) {
-            this.manager = manager;
-            this.state = {
-                name,
-                template,
-            };
-        }
-    };
-}
-export { RenderDefinition, NON_SINGLETON_RENDER_MANAGER, SINGLETON_RENDER_MANAGER };