@angular/core/esm2015/src/view/view_attach.js

Angular - the core framework

/**
 * @fileoverview added by tsickle
 * Generated from: packages/core/src/view/view_attach.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @license
 * Copyright Google Inc. All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
import { addToArray, removeFromArray } from '../util/array_utils';
import { Services } from './types';
import { declaredViewContainer, renderNode, visitRootRenderNodes } from './util';
/**
 * @param {?} parentView
 * @param {?} elementData
 * @param {?} viewIndex
 * @param {?} view
 * @return {?}
 */
export function attachEmbeddedView(parentView, elementData, viewIndex, view) {
    /** @type {?} */
    let embeddedViews = (/** @type {?} */ (elementData.viewContainer))._embeddedViews;
    if (viewIndex === null || viewIndex === undefined) {
        viewIndex = embeddedViews.length;
    }
    view.viewContainerParent = parentView;
    addToArray(embeddedViews, (/** @type {?} */ (viewIndex)), view);
    attachProjectedView(elementData, view);
    Services.dirtyParentQueries(view);
    /** @type {?} */
    const prevView = (/** @type {?} */ (viewIndex)) > 0 ? embeddedViews[(/** @type {?} */ (viewIndex)) - 1] : null;
    renderAttachEmbeddedView(elementData, prevView, view);
}
/**
 * @param {?} vcElementData
 * @param {?} view
 * @return {?}
 */
function attachProjectedView(vcElementData, view) {
    /** @type {?} */
    const dvcElementData = declaredViewContainer(view);
    if (!dvcElementData || dvcElementData === vcElementData ||
        view.state & 16 /* IsProjectedView */) {
        return;
    }
    // Note: For performance reasons, we
    // - add a view to template._projectedViews only 1x throughout its lifetime,
    //   and remove it not until the view is destroyed.
    //   (hard, as when a parent view is attached/detached we would need to attach/detach all
    //    nested projected views as well, even across component boundaries).
    // - don't track the insertion order of views in the projected views array
    //   (hard, as when the views of the same template are inserted different view containers)
    view.state |= 16 /* IsProjectedView */;
    /** @type {?} */
    let projectedViews = dvcElementData.template._projectedViews;
    if (!projectedViews) {
        projectedViews = dvcElementData.template._projectedViews = [];
    }
    projectedViews.push(view);
    // Note: we are changing the NodeDef here as we cannot calculate
    // the fact whether a template is used for projection during compilation.
    markNodeAsProjectedTemplate((/** @type {?} */ (view.parent)).def, (/** @type {?} */ (view.parentNodeDef)));
}
/**
 * @param {?} viewDef
 * @param {?} nodeDef
 * @return {?}
 */
function markNodeAsProjectedTemplate(viewDef, nodeDef) {
    if (nodeDef.flags & 4 /* ProjectedTemplate */) {
        return;
    }
    viewDef.nodeFlags |= 4 /* ProjectedTemplate */;
    nodeDef.flags |= 4 /* ProjectedTemplate */;
    /** @type {?} */
    let parentNodeDef = nodeDef.parent;
    while (parentNodeDef) {
        parentNodeDef.childFlags |= 4 /* ProjectedTemplate */;
        parentNodeDef = parentNodeDef.parent;
    }
}
/**
 * @param {?} elementData
 * @param {?=} viewIndex
 * @return {?}
 */
export function detachEmbeddedView(elementData, viewIndex) {
    /** @type {?} */
    const embeddedViews = (/** @type {?} */ (elementData.viewContainer))._embeddedViews;
    if (viewIndex == null || viewIndex >= embeddedViews.length) {
        viewIndex = embeddedViews.length - 1;
    }
    if (viewIndex < 0) {
        return null;
    }
    /** @type {?} */
    const view = embeddedViews[viewIndex];
    view.viewContainerParent = null;
    removeFromArray(embeddedViews, viewIndex);
    // See attachProjectedView for why we don't update projectedViews here.
    Services.dirtyParentQueries(view);
    renderDetachView(view);
    return view;
}
/**
 * @param {?} view
 * @return {?}
 */
export function detachProjectedView(view) {
    if (!(view.state & 16 /* IsProjectedView */)) {
        return;
    }
    /** @type {?} */
    const dvcElementData = declaredViewContainer(view);
    if (dvcElementData) {
        /** @type {?} */
        const projectedViews = dvcElementData.template._projectedViews;
        if (projectedViews) {
            removeFromArray(projectedViews, projectedViews.indexOf(view));
            Services.dirtyParentQueries(view);
        }
    }
}
/**
 * @param {?} elementData
 * @param {?} oldViewIndex
 * @param {?} newViewIndex
 * @return {?}
 */
export function moveEmbeddedView(elementData, oldViewIndex, newViewIndex) {
    /** @type {?} */
    const embeddedViews = (/** @type {?} */ (elementData.viewContainer))._embeddedViews;
    /** @type {?} */
    const view = embeddedViews[oldViewIndex];
    removeFromArray(embeddedViews, oldViewIndex);
    if (newViewIndex == null) {
        newViewIndex = embeddedViews.length;
    }
    addToArray(embeddedViews, newViewIndex, view);
    // Note: Don't need to change projectedViews as the order in there
    // as always invalid...
    Services.dirtyParentQueries(view);
    renderDetachView(view);
    /** @type {?} */
    const prevView = newViewIndex > 0 ? embeddedViews[newViewIndex - 1] : null;
    renderAttachEmbeddedView(elementData, prevView, view);
    return view;
}
/**
 * @param {?} elementData
 * @param {?} prevView
 * @param {?} view
 * @return {?}
 */
function renderAttachEmbeddedView(elementData, prevView, view) {
    /** @type {?} */
    const prevRenderNode = prevView ? renderNode(prevView, (/** @type {?} */ (prevView.def.lastRenderRootNode))) : elementData.renderElement;
    /** @type {?} */
    const parentNode = view.renderer.parentNode(prevRenderNode);
    /** @type {?} */
    const nextSibling = view.renderer.nextSibling(prevRenderNode);
    // Note: We can't check if `nextSibling` is present, as on WebWorkers it will always be!
    // However, browsers automatically do `appendChild` when there is no `nextSibling`.
    visitRootRenderNodes(view, 2 /* InsertBefore */, parentNode, nextSibling, undefined);
}
/**
 * @param {?} view
 * @return {?}
 */
export function renderDetachView(view) {
    visitRootRenderNodes(view, 3 /* RemoveChild */, null, null, undefined);
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"view_attach.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/view/view_attach.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {addToArray, removeFromArray} from '../util/array_utils';\n\nimport {ElementData, NodeDef, NodeFlags, Services, ViewData, ViewDefinition, ViewState} from './types';\nimport {declaredViewContainer, renderNode, RenderNodeAction, visitRootRenderNodes} from './util';\n\nexport function attachEmbeddedView(\n    parentView: ViewData, elementData: ElementData, viewIndex: number|undefined|null,\n    view: ViewData) {\n  let embeddedViews = elementData.viewContainer!._embeddedViews;\n  if (viewIndex === null || viewIndex === undefined) {\n    viewIndex = embeddedViews.length;\n  }\n  view.viewContainerParent = parentView;\n  addToArray(embeddedViews, viewIndex!, view);\n  attachProjectedView(elementData, view);\n\n  Services.dirtyParentQueries(view);\n\n  const prevView = viewIndex! > 0 ? embeddedViews[viewIndex! - 1] : null;\n  renderAttachEmbeddedView(elementData, prevView, view);\n}\n\nfunction attachProjectedView(vcElementData: ElementData, view: ViewData) {\n  const dvcElementData = declaredViewContainer(view);\n  if (!dvcElementData || dvcElementData === vcElementData ||\n      view.state & ViewState.IsProjectedView) {\n    return;\n  }\n  // Note: For performance reasons, we\n  // - add a view to template._projectedViews only 1x throughout its lifetime,\n  //   and remove it not until the view is destroyed.\n  //   (hard, as when a parent view is attached/detached we would need to attach/detach all\n  //    nested projected views as well, even across component boundaries).\n  // - don't track the insertion order of views in the projected views array\n  //   (hard, as when the views of the same template are inserted different view containers)\n  view.state |= ViewState.IsProjectedView;\n  let projectedViews = dvcElementData.template._projectedViews;\n  if (!projectedViews) {\n    projectedViews = dvcElementData.template._projectedViews = [];\n  }\n  projectedViews.push(view);\n  // Note: we are changing the NodeDef here as we cannot calculate\n  // the fact whether a template is used for projection during compilation.\n  markNodeAsProjectedTemplate(view.parent!.def, view.parentNodeDef!);\n}\n\nfunction markNodeAsProjectedTemplate(viewDef: ViewDefinition, nodeDef: NodeDef) {\n  if (nodeDef.flags & NodeFlags.ProjectedTemplate) {\n    return;\n  }\n  viewDef.nodeFlags |= NodeFlags.ProjectedTemplate;\n  nodeDef.flags |= NodeFlags.ProjectedTemplate;\n  let parentNodeDef = nodeDef.parent;\n  while (parentNodeDef) {\n    parentNodeDef.childFlags |= NodeFlags.ProjectedTemplate;\n    parentNodeDef = parentNodeDef.parent;\n  }\n}\n\nexport function detachEmbeddedView(elementData: ElementData, viewIndex?: number): ViewData|null {\n  const embeddedViews = elementData.viewContainer!._embeddedViews;\n  if (viewIndex == null || viewIndex >= embeddedViews.length) {\n    viewIndex = embeddedViews.length - 1;\n  }\n  if (viewIndex < 0) {\n    return null;\n  }\n  const view = embeddedViews[viewIndex];\n  view.viewContainerParent = null;\n  removeFromArray(embeddedViews, viewIndex);\n\n  // See attachProjectedView for why we don't update projectedViews here.\n  Services.dirtyParentQueries(view);\n\n  renderDetachView(view);\n\n  return view;\n}\n\nexport function detachProjectedView(view: ViewData) {\n  if (!(view.state & ViewState.IsProjectedView)) {\n    return;\n  }\n  const dvcElementData = declaredViewContainer(view);\n  if (dvcElementData) {\n    const projectedViews = dvcElementData.template._projectedViews;\n    if (projectedViews) {\n      removeFromArray(projectedViews, projectedViews.indexOf(view));\n      Services.dirtyParentQueries(view);\n    }\n  }\n}\n\nexport function moveEmbeddedView(\n    elementData: ElementData, oldViewIndex: number, newViewIndex: number): ViewData {\n  const embeddedViews = elementData.viewContainer!._embeddedViews;\n  const view = embeddedViews[oldViewIndex];\n  removeFromArray(embeddedViews, oldViewIndex);\n  if (newViewIndex == null) {\n    newViewIndex = embeddedViews.length;\n  }\n  addToArray(embeddedViews, newViewIndex, view);\n\n  // Note: Don't need to change projectedViews as the order in there\n  // as always invalid...\n\n  Services.dirtyParentQueries(view);\n\n  renderDetachView(view);\n  const prevView = newViewIndex > 0 ? embeddedViews[newViewIndex - 1] : null;\n  renderAttachEmbeddedView(elementData, prevView, view);\n\n  return view;\n}\n\nfunction renderAttachEmbeddedView(\n    elementData: ElementData, prevView: ViewData|null, view: ViewData) {\n  const prevRenderNode =\n      prevView ? renderNode(prevView, prevView.def.lastRenderRootNode!) : elementData.renderElement;\n  const parentNode = view.renderer.parentNode(prevRenderNode);\n  const nextSibling = view.renderer.nextSibling(prevRenderNode);\n  // Note: We can't check if `nextSibling` is present, as on WebWorkers it will always be!\n  // However, browsers automatically do `appendChild` when there is no `nextSibling`.\n  visitRootRenderNodes(view, RenderNodeAction.InsertBefore, parentNode, nextSibling, undefined);\n}\n\nexport function renderDetachView(view: ViewData) {\n  visitRootRenderNodes(view, RenderNodeAction.RemoveChild, null, null, undefined);\n}\n"]}