_id stringlengths 2 6 | title stringlengths 0 58 | partition stringclasses 3 values | text stringlengths 52 373k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q26700 | isNodeMatchingSelector | train | function isNodeMatchingSelector(tNode, selector) {
ngDevMode && assertDefined(selector[0], 'Selector should have a tag name');
var mode = 4 /* ELEMENT */;
var nodeAttrs = tNode.attrs;
var selectOnlyMarkerIdx = nodeAttrs ? nodeAttrs.indexOf(1 /* SelectOnly */) : -1;
// When processing ":not" selectors, we skip to the next ":not" if the
// current one doesn't match
var skipToNextSelector = false;
for (var i = 0; i < selector.length; i++) {
var current = selector[i];
if (typeof current === 'number') {
// If we finish processing a :not selector and it hasn't failed, return false
if (!skipToNextSelector && !isPositive(mode) && !isPositive(current)) {
return false;
}
// If we are skipping to the next :not() and this mode flag is positive,
// it's a part of the current :not() selector, and we should keep skipping
if (skipToNextSelector && isPositive(current))
continue;
skipToNextSelector = false;
mode = current | (mode & 1 /* NOT */);
continue;
}
if (skipToNextSelector)
continue;
if (mode & 4 /* ELEMENT */) {
mode = 2 /* ATTRIBUTE */ | mode & 1 /* NOT */;
if (current !== '' && current !== tNode.tagName) {
if (isPositive(mode))
return false;
skipToNextSelector = true;
}
}
else {
var attrName = mode & 8 /* CLASS */ ? 'class' : current;
var attrIndexInNode = findAttrIndexInNode(attrName, nodeAttrs);
if (attrIndexInNode === -1) {
if (isPositive(mode))
return false;
skipToNextSelector = true;
continue;
}
var selectorAttrValue = mode & 8 /* CLASS */ ? current : selector[++i];
if (selectorAttrValue !== '') {
var nodeAttrValue = void 0;
var maybeAttrName = nodeAttrs[attrIndexInNode];
if (selectOnlyMarkerIdx > -1 && attrIndexInNode > selectOnlyMarkerIdx) {
nodeAttrValue = '';
}
else {
ngDevMode && assertNotEqual(maybeAttrName, 0 /* NamespaceURI */, 'We do not match directives on namespaced attributes');
nodeAttrValue = nodeAttrs[attrIndexInNode + 1];
}
if (mode & 8 /* CLASS */ &&
!isCssClassMatching(nodeAttrValue, selectorAttrValue) ||
mode & 2 /* ATTRIBUTE */ && selectorAttrValue !== nodeAttrValue) {
if (isPositive(mode))
return false;
skipToNextSelector = true;
}
}
}
}
return isPositive(mode) || skipToNextSelector;
} | javascript | {
"resource": ""
} |
q26701 | findAttrIndexInNode | train | function findAttrIndexInNode(name, attrs) {
if (attrs === null)
return -1;
var selectOnlyMode = false;
var i = 0;
while (i < attrs.length) {
var maybeAttrName = attrs[i];
if (maybeAttrName === name) {
return i;
}
else if (maybeAttrName === 0 /* NamespaceURI */) {
// NOTE(benlesh): will not find namespaced attributes. This is by design.
i += 4;
}
else {
if (maybeAttrName === 1 /* SelectOnly */) {
selectOnlyMode = true;
}
i += selectOnlyMode ? 1 : 2;
}
}
return -1;
} | javascript | {
"resource": ""
} |
q26702 | renderStyling | train | function renderStyling(context, renderer, styleStore, classStore) {
if (isContextDirty(context)) {
var native = context[0 /* ElementPosition */].native;
var multiStartIndex = getMultiStartIndex(context);
var styleSanitizer = getStyleSanitizer(context);
for (var i = 6 /* SingleStylesStartPosition */; i < context.length; i += 3 /* Size */) {
// there is no point in rendering styles that have not changed on screen
if (isDirty(context, i)) {
var prop = getProp(context, i);
var value = getValue(context, i);
var flag = getPointers(context, i);
var isClassBased_6 = flag & 2 /* Class */ ? true : false;
var isInSingleRegion = i < multiStartIndex;
var valueToApply = value;
// VALUE DEFER CASE 1: Use a multi value instead of a null single value
// this check implies that a single value was removed and we
// should now defer to a multi value and use that (if set).
if (isInSingleRegion && !valueExists(valueToApply, isClassBased_6)) {
// single values ALWAYS have a reference to a multi index
var multiIndex = getMultiOrSingleIndex(flag);
valueToApply = getValue(context, multiIndex);
}
// VALUE DEFER CASE 2: Use the initial value if all else fails (is falsy)
// the initial value will always be a string or null,
// therefore we can safely adopt it incase there's nothing else
// note that this should always be a falsy check since `false` is used
// for both class and style comparisons (styles can't be false and false
// classes are turned off and should therefore defer to their initial values)
if (!valueExists(valueToApply, isClassBased_6)) {
valueToApply = getInitialValue(context, flag);
}
if (isClassBased_6) {
setClass(native, prop, valueToApply ? true : false, renderer, classStore);
}
else {
var sanitizer = (flag & 4 /* Sanitize */) ? styleSanitizer : null;
setStyle(native, prop, valueToApply, renderer, sanitizer, styleStore);
}
setDirty(context, i, false);
}
}
setContextDirty(context, false);
}
} | javascript | {
"resource": ""
} |
q26703 | enterView | train | function enterView(newView, host) {
var oldView = viewData;
directives = newView && newView[DIRECTIVES];
tView = newView && newView[TVIEW];
creationMode = newView && (newView[FLAGS] & 1 /* CreationMode */) === 1 /* CreationMode */;
firstTemplatePass = newView && tView.firstTemplatePass;
renderer = newView && newView[RENDERER];
if (host != null) {
previousOrParentNode = host;
isParent = true;
}
viewData = newView;
currentQueries = newView && newView[QUERIES];
return oldView;
} | javascript | {
"resource": ""
} |
q26704 | setHostBindings | train | function setHostBindings(bindings) {
if (bindings != null) {
var defs = tView.directives;
for (var i = 0; i < bindings.length; i += 2) {
var dirIndex = bindings[i];
var def = defs[dirIndex];
def.hostBindings && def.hostBindings(dirIndex, bindings[i + 1]);
}
}
} | javascript | {
"resource": ""
} |
q26705 | refreshContentQueries | train | function refreshContentQueries(tView) {
if (tView.contentQueries != null) {
for (var i = 0; i < tView.contentQueries.length; i += 2) {
var directiveDefIdx = tView.contentQueries[i];
var directiveDef = tView.directives[directiveDefIdx];
directiveDef.contentQueriesRefresh(directiveDefIdx, tView.contentQueries[i + 1]);
}
}
} | javascript | {
"resource": ""
} |
q26706 | refreshChildComponents | train | function refreshChildComponents(components) {
if (components != null) {
for (var i = 0; i < components.length; i += 2) {
componentRefresh(components[i], components[i + 1]);
}
}
} | javascript | {
"resource": ""
} |
q26707 | elementCreate | train | function elementCreate(name, overriddenRenderer) {
var native;
var rendererToUse = overriddenRenderer || renderer;
if (isProceduralRenderer(rendererToUse)) {
native = rendererToUse.createElement(name, _currentNamespace);
}
else {
if (_currentNamespace === null) {
native = rendererToUse.createElement(name);
}
else {
native = rendererToUse.createElementNS(_currentNamespace, name);
}
}
return native;
} | javascript | {
"resource": ""
} |
q26708 | createDirectivesAndLocals | train | function createDirectivesAndLocals(localRefs) {
var node = previousOrParentNode;
if (firstTemplatePass) {
ngDevMode && ngDevMode.firstTemplatePass++;
cacheMatchingDirectivesForNode(node.tNode, tView, localRefs || null);
}
else {
instantiateDirectivesDirectly();
}
saveResolvedLocalsInData();
} | javascript | {
"resource": ""
} |
q26709 | findDirectiveMatches | train | function findDirectiveMatches(tNode) {
var registry = tView.directiveRegistry;
var matches = null;
if (registry) {
for (var i = 0; i < registry.length; i++) {
var def = registry[i];
if (isNodeMatchingSelectorList(tNode, def.selectors)) {
if (def.template) {
if (tNode.flags & 4096 /* isComponent */)
throwMultipleComponentError(tNode);
tNode.flags = 4096 /* isComponent */;
}
if (def.diPublic)
def.diPublic(def);
(matches || (matches = [])).push(def, null);
}
}
}
return matches;
} | javascript | {
"resource": ""
} |
q26710 | queueComponentIndexForCheck | train | function queueComponentIndexForCheck(dirIndex) {
if (firstTemplatePass) {
(tView.components || (tView.components = [])).push(dirIndex, viewData.length - 1);
}
} | javascript | {
"resource": ""
} |
q26711 | queueHostBindingForCheck | train | function queueHostBindingForCheck(dirIndex) {
// Must subtract the header offset because hostBindings functions are generated with
// instructions that expect element indices that are NOT adjusted (e.g. elementProperty).
ngDevMode &&
assertEqual(firstTemplatePass, true, 'Should only be called in first template pass.');
(tView.hostBindings || (tView.hostBindings = [])).push(dirIndex, viewData.length - 1 - HEADER_OFFSET);
} | javascript | {
"resource": ""
} |
q26712 | initChangeDetectorIfExisting | train | function initChangeDetectorIfExisting(injector, instance, view) {
if (injector && injector.changeDetectorRef != null) {
injector.changeDetectorRef._setComponentContext(view, instance);
}
} | javascript | {
"resource": ""
} |
q26713 | instantiateDirectivesDirectly | train | function instantiateDirectivesDirectly() {
var tNode = previousOrParentNode.tNode;
var count = tNode.flags & 4095 /* DirectiveCountMask */;
if (count > 0) {
var start = tNode.flags >> 14 /* DirectiveStartingIndexShift */;
var end = start + count;
var tDirectives = tView.directives;
for (var i = start; i < end; i++) {
var def = tDirectives[i];
directiveCreate(i, def.factory(), def);
}
}
} | javascript | {
"resource": ""
} |
q26714 | cacheMatchingLocalNames | train | function cacheMatchingLocalNames(tNode, localRefs, exportsMap) {
if (localRefs) {
var localNames = tNode.localNames = [];
// Local names must be stored in tNode in the same order that localRefs are defined
// in the template to ensure the data is loaded in the same slots as their refs
// in the template (for template queries).
for (var i = 0; i < localRefs.length; i += 2) {
var index = exportsMap[localRefs[i + 1]];
if (index == null)
throw new Error("Export of name '" + localRefs[i + 1] + "' not found!");
localNames.push(localRefs[i], index);
}
}
} | javascript | {
"resource": ""
} |
q26715 | saveNameToExportMap | train | function saveNameToExportMap(index, def, exportsMap) {
if (exportsMap) {
if (def.exportAs)
exportsMap[def.exportAs] = index;
if (def.template)
exportsMap[''] = index;
}
} | javascript | {
"resource": ""
} |
q26716 | getOrCreateTView | train | function getOrCreateTView(template, directives, pipes, viewQuery) {
// TODO(misko): reading `ngPrivateData` here is problematic for two reasons
// 1. It is a megamorphic call on each invocation.
// 2. For nested embedded views (ngFor inside ngFor) the template instance is per
// outer template invocation, which means that no such property will exist
// Correct solution is to only put `ngPrivateData` on the Component template
// and not on embedded templates.
return template.ngPrivateData ||
(template.ngPrivateData = createTView(-1, template, directives, pipes, viewQuery));
} | javascript | {
"resource": ""
} |
q26717 | createTView | train | function createTView(viewIndex, template, directives, pipes, viewQuery) {
ngDevMode && ngDevMode.tView++;
return {
id: viewIndex,
template: template,
viewQuery: viewQuery,
node: null,
data: HEADER_FILLER.slice(),
childIndex: -1,
bindingStartIndex: -1,
directives: null,
firstTemplatePass: true,
initHooks: null,
checkHooks: null,
contentHooks: null,
contentCheckHooks: null,
viewHooks: null,
viewCheckHooks: null,
destroyHooks: null,
pipeDestroyHooks: null,
cleanup: null,
hostBindings: null,
contentQueries: null,
components: null,
directiveRegistry: typeof directives === 'function' ? directives() : directives,
pipeRegistry: typeof pipes === 'function' ? pipes() : pipes,
currentMatches: null
};
} | javascript | {
"resource": ""
} |
q26718 | locateHostElement | train | function locateHostElement(factory, elementOrSelector) {
ngDevMode && assertDataInRange(-1);
rendererFactory = factory;
var defaultRenderer = factory.createRenderer(null, null);
var rNode = typeof elementOrSelector === 'string' ?
(isProceduralRenderer(defaultRenderer) ?
defaultRenderer.selectRootElement(elementOrSelector) :
defaultRenderer.querySelector(elementOrSelector)) :
elementOrSelector;
if (ngDevMode && !rNode) {
if (typeof elementOrSelector === 'string') {
throw createError('Host node with selector not found:', elementOrSelector);
}
else {
throw createError('Host node is required:', elementOrSelector);
}
}
return rNode;
} | javascript | {
"resource": ""
} |
q26719 | hostElement | train | function hostElement(tag, rNode, def, sanitizer) {
resetApplicationState();
var node = createLNode(0, 3 /* Element */, rNode, null, null, createLViewData(renderer, getOrCreateTView(def.template, def.directiveDefs, def.pipeDefs, def.viewQuery), null, def.onPush ? 4 /* Dirty */ : 2 /* CheckAlways */, sanitizer));
if (firstTemplatePass) {
node.tNode.flags = 4096 /* isComponent */;
if (def.diPublic)
def.diPublic(def);
tView.directives = [def];
}
return node;
} | javascript | {
"resource": ""
} |
q26720 | listener | train | function listener(eventName, listenerFn, useCapture) {
if (useCapture === void 0) { useCapture = false; }
ngDevMode && assertPreviousIsParent();
var node = previousOrParentNode;
var native = node.native;
ngDevMode && ngDevMode.rendererAddEventListener++;
// In order to match current behavior, native DOM event listeners must be added for all
// events (including outputs).
if (isProceduralRenderer(renderer)) {
var wrappedListener = wrapListenerWithDirtyLogic(viewData, listenerFn);
var cleanupFn = renderer.listen(native, eventName, wrappedListener);
storeCleanupFn(viewData, cleanupFn);
}
else {
var wrappedListener = wrapListenerWithDirtyAndDefault(viewData, listenerFn);
native.addEventListener(eventName, wrappedListener, useCapture);
var cleanupInstances = getCleanup(viewData);
cleanupInstances.push(wrappedListener);
if (firstTemplatePass) {
getTViewCleanup(viewData).push(eventName, node.tNode.index, cleanupInstances.length - 1, useCapture);
}
}
var tNode = node.tNode;
if (tNode.outputs === undefined) {
// if we create TNode here, inputs must be undefined so we know they still need to be
// checked
tNode.outputs = generatePropertyAliases(node.tNode.flags, 1 /* Output */);
}
var outputs = tNode.outputs;
var outputData;
if (outputs && (outputData = outputs[eventName])) {
createOutput(outputData, listenerFn);
}
} | javascript | {
"resource": ""
} |
q26721 | createOutput | train | function createOutput(outputs, listener) {
for (var i = 0; i < outputs.length; i += 2) {
ngDevMode && assertDataInRange(outputs[i], directives);
var subscription = directives[outputs[i]][outputs[i + 1]].subscribe(listener);
storeCleanupWithContext(viewData, subscription, subscription.unsubscribe);
}
} | javascript | {
"resource": ""
} |
q26722 | storeCleanupWithContext | train | function storeCleanupWithContext(view, context, cleanupFn) {
if (!view)
view = viewData;
getCleanup(view).push(context);
if (view[TVIEW].firstTemplatePass) {
getTViewCleanup(view).push(cleanupFn, view[CLEANUP].length - 1);
}
} | javascript | {
"resource": ""
} |
q26723 | storeCleanupFn | train | function storeCleanupFn(view, cleanupFn) {
getCleanup(view).push(cleanupFn);
if (view[TVIEW].firstTemplatePass) {
getTViewCleanup(view).push(view[CLEANUP].length - 1, null);
}
} | javascript | {
"resource": ""
} |
q26724 | elementEnd | train | function elementEnd() {
if (isParent) {
isParent = false;
}
else {
ngDevMode && assertHasParent();
previousOrParentNode = getParentLNode(previousOrParentNode);
}
ngDevMode && assertNodeType(previousOrParentNode, 3 /* Element */);
var queries = previousOrParentNode.queries;
queries && queries.addNode(previousOrParentNode);
queueLifecycleHooks(previousOrParentNode.tNode.flags, tView);
currentElementNode = null;
} | javascript | {
"resource": ""
} |
q26725 | elementAttribute | train | function elementAttribute(index, name, value, sanitizer) {
if (value !== NO_CHANGE) {
var element_1 = loadElement(index);
if (value == null) {
ngDevMode && ngDevMode.rendererRemoveAttribute++;
isProceduralRenderer(renderer) ? renderer.removeAttribute(element_1.native, name) :
element_1.native.removeAttribute(name);
}
else {
ngDevMode && ngDevMode.rendererSetAttribute++;
var strValue = sanitizer == null ? stringify$1(value) : sanitizer(value);
isProceduralRenderer(renderer) ? renderer.setAttribute(element_1.native, name, strValue) :
element_1.native.setAttribute(name, strValue);
}
}
} | javascript | {
"resource": ""
} |
q26726 | elementProperty | train | function elementProperty(index, propName, value, sanitizer) {
if (value === NO_CHANGE)
return;
var node = loadElement(index);
var tNode = node.tNode;
// if tNode.inputs is undefined, a listener has created outputs, but inputs haven't
// yet been checked
if (tNode && tNode.inputs === undefined) {
// mark inputs as checked
tNode.inputs = generatePropertyAliases(node.tNode.flags, 0 /* Input */);
}
var inputData = tNode && tNode.inputs;
var dataValue;
if (inputData && (dataValue = inputData[propName])) {
setInputsForProperty(dataValue, value);
markDirtyIfOnPush(node);
}
else {
// It is assumed that the sanitizer is only added when the compiler determines that the property
// is risky, so sanitization can be done without further checks.
value = sanitizer != null ? sanitizer(value) : value;
var native = node.native;
ngDevMode && ngDevMode.rendererSetProperty++;
isProceduralRenderer(renderer) ? renderer.setProperty(native, propName, value) :
(native.setProperty ? native.setProperty(propName, value) :
native[propName] = value);
}
} | javascript | {
"resource": ""
} |
q26727 | createTNode | train | function createTNode(type, adjustedIndex, tagName, attrs, parent, tViews) {
ngDevMode && ngDevMode.tNode++;
return {
type: type,
index: adjustedIndex,
flags: 0,
tagName: tagName,
attrs: attrs,
localNames: null,
initialInputs: undefined,
inputs: undefined,
outputs: undefined,
tViews: tViews,
next: null,
child: null,
parent: parent,
dynamicContainerNode: null,
detached: null,
stylingTemplate: null,
projection: null
};
} | javascript | {
"resource": ""
} |
q26728 | setInputsForProperty | train | function setInputsForProperty(inputs, value) {
for (var i = 0; i < inputs.length; i += 2) {
ngDevMode && assertDataInRange(inputs[i], directives);
directives[inputs[i]][inputs[i + 1]] = value;
}
} | javascript | {
"resource": ""
} |
q26729 | generatePropertyAliases | train | function generatePropertyAliases(tNodeFlags, direction) {
var count = tNodeFlags & 4095 /* DirectiveCountMask */;
var propStore = null;
if (count > 0) {
var start = tNodeFlags >> 14 /* DirectiveStartingIndexShift */;
var end = start + count;
var isInput = direction === 0 /* Input */;
var defs = tView.directives;
for (var i = start; i < end; i++) {
var directiveDef = defs[i];
var propertyAliasMap = isInput ? directiveDef.inputs : directiveDef.outputs;
for (var publicName in propertyAliasMap) {
if (propertyAliasMap.hasOwnProperty(publicName)) {
propStore = propStore || {};
var internalName = propertyAliasMap[publicName];
var hasProperty = propStore.hasOwnProperty(publicName);
hasProperty ? propStore[publicName].push(i, internalName) :
(propStore[publicName] = [i, internalName]);
}
}
}
}
return propStore;
} | javascript | {
"resource": ""
} |
q26730 | elementClassProp | train | function elementClassProp(index, stylingIndex, value) {
updateClassProp(getStylingContext(index), stylingIndex, value ? true : false);
} | javascript | {
"resource": ""
} |
q26731 | elementStyling | train | function elementStyling(classDeclarations, styleDeclarations, styleSanitizer) {
var lElement = currentElementNode;
var tNode = lElement.tNode;
if (!tNode.stylingTemplate) {
// initialize the styling template.
tNode.stylingTemplate =
createStylingContextTemplate(classDeclarations, styleDeclarations, styleSanitizer);
}
if (styleDeclarations && styleDeclarations.length ||
classDeclarations && classDeclarations.length) {
elementStylingApply(tNode.index - HEADER_OFFSET);
}
} | javascript | {
"resource": ""
} |
q26732 | getStylingContext | train | function getStylingContext(index) {
var stylingContext = load(index);
if (!Array.isArray(stylingContext)) {
var lElement = stylingContext;
var tNode = lElement.tNode;
ngDevMode &&
assertDefined(tNode.stylingTemplate, 'getStylingContext() called before elementStyling()');
stylingContext = viewData[index + HEADER_OFFSET] =
allocStylingContext(lElement, tNode.stylingTemplate);
}
return stylingContext;
} | javascript | {
"resource": ""
} |
q26733 | elementStyleProp | train | function elementStyleProp(index, styleIndex, value, suffix) {
var valueToAdd = null;
if (value) {
if (suffix) {
// when a suffix is applied then it will bypass
// sanitization entirely (b/c a new string is created)
valueToAdd = stringify$1(value) + suffix;
}
else {
// sanitization happens by dealing with a String value
// this means that the string value will be passed through
// into the style rendering later (which is where the value
// will be sanitized before it is applied)
valueToAdd = value;
}
}
updateStyleProp(getStylingContext(index), styleIndex, valueToAdd);
} | javascript | {
"resource": ""
} |
q26734 | setInputsFromAttrs | train | function setInputsFromAttrs(directiveIndex, instance, inputs, tNode) {
var initialInputData = tNode.initialInputs;
if (initialInputData === undefined || directiveIndex >= initialInputData.length) {
initialInputData = generateInitialInputs(directiveIndex, inputs, tNode);
}
var initialInputs = initialInputData[directiveIndex];
if (initialInputs) {
for (var i = 0; i < initialInputs.length; i += 2) {
instance[initialInputs[i]] = initialInputs[i + 1];
}
}
} | javascript | {
"resource": ""
} |
q26735 | generateInitialInputs | train | function generateInitialInputs(directiveIndex, inputs, tNode) {
var initialInputData = tNode.initialInputs || (tNode.initialInputs = []);
initialInputData[directiveIndex] = null;
var attrs = tNode.attrs;
var i = 0;
while (i < attrs.length) {
var attrName = attrs[i];
if (attrName === 1 /* SelectOnly */)
break;
if (attrName === 0 /* NamespaceURI */) {
// We do not allow inputs on namespaced attributes.
i += 4;
continue;
}
var minifiedInputName = inputs[attrName];
var attrValue = attrs[i + 1];
if (minifiedInputName !== undefined) {
var inputsToStore = initialInputData[directiveIndex] || (initialInputData[directiveIndex] = []);
inputsToStore.push(minifiedInputName, attrValue);
}
i += 2;
}
return initialInputData;
} | javascript | {
"resource": ""
} |
q26736 | container | train | function container(index, template, tagName, attrs, localRefs) {
ngDevMode &&
assertEqual(viewData[BINDING_INDEX], -1, 'container nodes should be created before any bindings');
var currentParent = isParent ? previousOrParentNode : getParentLNode(previousOrParentNode);
var lContainer = createLContainer(currentParent, viewData);
var comment = renderer.createComment(ngDevMode ? 'container' : '');
var node = createLNode(index, 0 /* Container */, comment, tagName || null, attrs || null, lContainer);
appendChild(getParentLNode(node), comment, viewData);
if (firstTemplatePass) {
node.tNode.tViews = template ?
createTView(-1, template, tView.directiveRegistry, tView.pipeRegistry, null) :
[];
}
// Containers are added to the current view tree instead of their embedded views
// because views can be removed and re-inserted.
addToViewTree(viewData, index + HEADER_OFFSET, node.data);
var queries = node.queries;
if (queries) {
// prepare place for matching nodes from views inserted into a given container
lContainer[QUERIES] = queries.container();
}
createDirectivesAndLocals(localRefs);
isParent = false;
ngDevMode && assertNodeType(previousOrParentNode, 0 /* Container */);
queries && queries.addNode(node); // check if a given container node matches
queueLifecycleHooks(node.tNode.flags, tView);
} | javascript | {
"resource": ""
} |
q26737 | containerRefreshStart | train | function containerRefreshStart(index) {
previousOrParentNode = loadElement(index);
ngDevMode && assertNodeType(previousOrParentNode, 0 /* Container */);
isParent = true;
previousOrParentNode.data[ACTIVE_INDEX] = 0;
if (!checkNoChangesMode) {
// We need to execute init hooks here so ngOnInit hooks are called in top level views
// before they are called in embedded views (for backwards compatibility).
executeInitHooks(viewData, tView, creationMode);
}
} | javascript | {
"resource": ""
} |
q26738 | containerRefreshEnd | train | function containerRefreshEnd() {
if (isParent) {
isParent = false;
}
else {
ngDevMode && assertNodeType(previousOrParentNode, 2 /* View */);
ngDevMode && assertHasParent();
previousOrParentNode = getParentLNode(previousOrParentNode);
}
ngDevMode && assertNodeType(previousOrParentNode, 0 /* Container */);
var container = previousOrParentNode;
ngDevMode && assertNodeType(container, 0 /* Container */);
var nextIndex = container.data[ACTIVE_INDEX];
// remove extra views at the end of the container
while (nextIndex < container.data[VIEWS].length) {
removeView(container, nextIndex);
}
} | javascript | {
"resource": ""
} |
q26739 | scanForView | train | function scanForView(containerNode, startIdx, viewBlockId) {
var views = containerNode.data[VIEWS];
for (var i = startIdx; i < views.length; i++) {
var viewAtPositionId = views[i].data[TVIEW].id;
if (viewAtPositionId === viewBlockId) {
return views[i];
}
else if (viewAtPositionId < viewBlockId) {
// found a view that should not be at this position - remove
removeView(containerNode, i);
}
else {
// found a view with id greater than the one we are searching for
// which means that required view doesn't exist and can't be found at
// later positions in the views array - stop the search here
break;
}
}
return null;
} | javascript | {
"resource": ""
} |
q26740 | embeddedViewStart | train | function embeddedViewStart(viewBlockId) {
var container = (isParent ? previousOrParentNode : getParentLNode(previousOrParentNode));
ngDevMode && assertNodeType(container, 0 /* Container */);
var lContainer = container.data;
var viewNode = scanForView(container, lContainer[ACTIVE_INDEX], viewBlockId);
if (viewNode) {
previousOrParentNode = viewNode;
ngDevMode && assertNodeType(previousOrParentNode, 2 /* View */);
isParent = true;
enterView(viewNode.data, viewNode);
}
else {
// When we create a new LView, we always reset the state of the instructions.
var newView = createLViewData(renderer, getOrCreateEmbeddedTView(viewBlockId, container), null, 2 /* CheckAlways */, getCurrentSanitizer());
if (lContainer[QUERIES]) {
newView[QUERIES] = lContainer[QUERIES].createView();
}
enterView(newView, viewNode = createLNode(viewBlockId, 2 /* View */, null, null, null, newView));
}
if (container) {
if (creationMode) {
// it is a new view, insert it into collection of views for a given container
insertView(container, viewNode, lContainer[ACTIVE_INDEX]);
}
lContainer[ACTIVE_INDEX]++;
}
return getRenderFlags(viewNode.data);
} | javascript | {
"resource": ""
} |
q26741 | embeddedViewEnd | train | function embeddedViewEnd() {
refreshView();
isParent = false;
previousOrParentNode = viewData[HOST_NODE];
leaveView(viewData[PARENT]);
ngDevMode && assertEqual(isParent, false, 'isParent');
ngDevMode && assertNodeType(previousOrParentNode, 2 /* View */);
} | javascript | {
"resource": ""
} |
q26742 | projection | train | function projection(nodeIndex, selectorIndex, attrs) {
if (selectorIndex === void 0) { selectorIndex = 0; }
var node = createLNode(nodeIndex, 1 /* Projection */, null, null, attrs || null, null);
// We can't use viewData[HOST_NODE] because projection nodes can be nested in embedded views.
if (node.tNode.projection === null)
node.tNode.projection = selectorIndex;
// `<ng-content>` has no content
isParent = false;
// re-distribution of projectable nodes is stored on a component's view level
var parent = getParentLNode(node);
if (canInsertNativeNode(parent, viewData)) {
var componentNode = findComponentHost(viewData);
var nodeToProject = componentNode.tNode.projection[selectorIndex];
var projectedView = componentNode.view;
var projectionNodeIndex = -1;
var grandparent = void 0;
var renderParent = parent.tNode.type === 2 /* View */ ?
(grandparent = getParentLNode(parent)) &&
grandparent.data[RENDER_PARENT] :
parent;
while (nodeToProject) {
if (nodeToProject.type === 1 /* Projection */) {
// This node is re-projected, so we must go up the tree to get its projected nodes.
var currentComponentHost = findComponentHost(projectedView);
var firstProjectedNode = currentComponentHost.tNode.projection[nodeToProject.projection];
if (firstProjectedNode) {
projectionNodeStack$1[++projectionNodeIndex] = projectedView[nodeToProject.index];
nodeToProject = firstProjectedNode;
projectedView = currentComponentHost.view;
continue;
}
}
else {
var lNode = projectedView[nodeToProject.index];
lNode.tNode.flags |= 8192 /* isProjected */;
appendProjectedNode(lNode, parent, viewData, renderParent);
}
// If we are finished with a list of re-projected nodes, we need to get
// back to the root projection node that was re-projected.
if (nodeToProject.next === null && projectedView !== componentNode.view) {
// move down into the view of the component we're projecting right now
var lNode = projectionNodeStack$1[projectionNodeIndex--];
nodeToProject = lNode.tNode;
projectedView = lNode.view;
}
nodeToProject = nodeToProject.next;
}
}
} | javascript | {
"resource": ""
} |
q26743 | addToViewTree | train | function addToViewTree(currentView, adjustedHostIndex, state) {
if (currentView[TAIL]) {
currentView[TAIL][NEXT] = state;
}
else if (firstTemplatePass) {
tView.childIndex = adjustedHostIndex;
}
currentView[TAIL] = state;
return state;
} | javascript | {
"resource": ""
} |
q26744 | wrapListenerWithDirtyAndDefault | train | function wrapListenerWithDirtyAndDefault(view, listenerFn) {
return function wrapListenerIn_markViewDirty(e) {
markViewDirty(view);
if (listenerFn(e) === false) {
e.preventDefault();
// Necessary for legacy browsers that don't support preventDefault (e.g. IE)
e.returnValue = false;
}
};
} | javascript | {
"resource": ""
} |
q26745 | markViewDirty | train | function markViewDirty(view) {
var currentView = view;
while (currentView[PARENT] != null) {
currentView[FLAGS] |= 4 /* Dirty */;
currentView = currentView[PARENT];
}
currentView[FLAGS] |= 4 /* Dirty */;
ngDevMode && assertDefined(currentView[CONTEXT], 'rootContext');
scheduleTick(currentView[CONTEXT]);
} | javascript | {
"resource": ""
} |
q26746 | scheduleTick | train | function scheduleTick(rootContext) {
if (rootContext.clean == _CLEAN_PROMISE) {
var res_1;
rootContext.clean = new Promise(function (r) { return res_1 = r; });
rootContext.scheduler(function () {
tickRootContext(rootContext);
res_1(null);
rootContext.clean = _CLEAN_PROMISE;
});
}
} | javascript | {
"resource": ""
} |
q26747 | getRootView | train | function getRootView(component) {
ngDevMode && assertDefined(component, 'component');
var lElementNode = _getComponentHostLElementNode(component);
var lViewData = lElementNode.view;
while (lViewData[PARENT]) {
lViewData = lViewData[PARENT];
}
return lViewData;
} | javascript | {
"resource": ""
} |
q26748 | detectChangesInternal | train | function detectChangesInternal(hostView, hostNode, component) {
var oldView = enterView(hostView, hostNode);
var hostTView = hostView[TVIEW];
var template = hostTView.template;
var viewQuery = hostTView.viewQuery;
try {
namespaceHTML();
createViewQuery(viewQuery, hostView[FLAGS], component);
template(getRenderFlags(hostView), component);
refreshView();
updateViewQuery(viewQuery, component);
}
finally {
leaveView(oldView);
}
} | javascript | {
"resource": ""
} |
q26749 | initBindings | train | function initBindings() {
ngDevMode && assertEqual(viewData[BINDING_INDEX], -1, 'Binding index should not yet be set ' + viewData[BINDING_INDEX]);
if (tView.bindingStartIndex === -1) {
tView.bindingStartIndex = viewData.length;
}
viewData[BINDING_INDEX] = tView.bindingStartIndex;
} | javascript | {
"resource": ""
} |
q26750 | moveBindingIndexToReservedSlot | train | function moveBindingIndexToReservedSlot(offset) {
var currentSlot = viewData[BINDING_INDEX];
viewData[BINDING_INDEX] = tView.bindingStartIndex - offset;
return currentSlot;
} | javascript | {
"resource": ""
} |
q26751 | interpolationV | train | function interpolationV(values) {
ngDevMode && assertLessThan(2, values.length, 'should have at least 3 values');
ngDevMode && assertEqual(values.length % 2, 1, 'should have an odd number of values');
var different = false;
for (var i = 1; i < values.length; i += 2) {
// Check if bindings (odd indexes) have changed
bindingUpdated(values[i]) && (different = true);
}
if (!different) {
return NO_CHANGE;
}
// Build the updated content
var content = values[0];
for (var i = 1; i < values.length; i += 2) {
content += stringify$1(values[i]) + values[i + 1];
}
return content;
} | javascript | {
"resource": ""
} |
q26752 | interpolation1 | train | function interpolation1(prefix, v0, suffix) {
var different = bindingUpdated(v0);
return different ? prefix + stringify$1(v0) + suffix : NO_CHANGE;
} | javascript | {
"resource": ""
} |
q26753 | interpolation2 | train | function interpolation2(prefix, v0, i0, v1, suffix) {
var different = bindingUpdated2(v0, v1);
return different ? prefix + stringify$1(v0) + i0 + stringify$1(v1) + suffix : NO_CHANGE;
} | javascript | {
"resource": ""
} |
q26754 | interpolation3 | train | function interpolation3(prefix, v0, i0, v1, i1, v2, suffix) {
var different = bindingUpdated2(v0, v1);
different = bindingUpdated(v2) || different;
return different ? prefix + stringify$1(v0) + i0 + stringify$1(v1) + i1 + stringify$1(v2) + suffix :
NO_CHANGE;
} | javascript | {
"resource": ""
} |
q26755 | interpolation4 | train | function interpolation4(prefix, v0, i0, v1, i1, v2, i2, v3, suffix) {
var different = bindingUpdated4(v0, v1, v2, v3);
return different ?
prefix + stringify$1(v0) + i0 + stringify$1(v1) + i1 + stringify$1(v2) + i2 + stringify$1(v3) +
suffix :
NO_CHANGE;
} | javascript | {
"resource": ""
} |
q26756 | interpolation5 | train | function interpolation5(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, suffix) {
var different = bindingUpdated4(v0, v1, v2, v3);
different = bindingUpdated(v4) || different;
return different ?
prefix + stringify$1(v0) + i0 + stringify$1(v1) + i1 + stringify$1(v2) + i2 + stringify$1(v3) + i3 +
stringify$1(v4) + suffix :
NO_CHANGE;
} | javascript | {
"resource": ""
} |
q26757 | interpolation6 | train | function interpolation6(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, suffix) {
var different = bindingUpdated4(v0, v1, v2, v3);
different = bindingUpdated2(v4, v5) || different;
return different ?
prefix + stringify$1(v0) + i0 + stringify$1(v1) + i1 + stringify$1(v2) + i2 + stringify$1(v3) + i3 +
stringify$1(v4) + i4 + stringify$1(v5) + suffix :
NO_CHANGE;
} | javascript | {
"resource": ""
} |
q26758 | interpolation7 | train | function interpolation7(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, suffix) {
var different = bindingUpdated4(v0, v1, v2, v3);
different = bindingUpdated2(v4, v5) || different;
different = bindingUpdated(v6) || different;
return different ?
prefix + stringify$1(v0) + i0 + stringify$1(v1) + i1 + stringify$1(v2) + i2 + stringify$1(v3) + i3 +
stringify$1(v4) + i4 + stringify$1(v5) + i5 + stringify$1(v6) + suffix :
NO_CHANGE;
} | javascript | {
"resource": ""
} |
q26759 | interpolation8 | train | function interpolation8(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, i6, v7, suffix) {
var different = bindingUpdated4(v0, v1, v2, v3);
different = bindingUpdated4(v4, v5, v6, v7) || different;
return different ?
prefix + stringify$1(v0) + i0 + stringify$1(v1) + i1 + stringify$1(v2) + i2 + stringify$1(v3) + i3 +
stringify$1(v4) + i4 + stringify$1(v5) + i5 + stringify$1(v6) + i6 + stringify$1(v7) + suffix :
NO_CHANGE;
} | javascript | {
"resource": ""
} |
q26760 | store | train | function store(index, value) {
// We don't store any static data for local variables, so the first time
// we see the template, we should store as null to avoid a sparse array
var adjustedIndex = index + HEADER_OFFSET;
if (adjustedIndex >= tView.data.length) {
tView.data[adjustedIndex] = null;
}
viewData[adjustedIndex] = value;
} | javascript | {
"resource": ""
} |
q26761 | loadDirective | train | function loadDirective(index) {
ngDevMode && assertDefined(directives, 'Directives array should be defined if reading a dir.');
ngDevMode && assertDataInRange(index, directives);
return directives[index];
} | javascript | {
"resource": ""
} |
q26762 | consumeBinding | train | function consumeBinding() {
ngDevMode && assertDataInRange(viewData[BINDING_INDEX]);
ngDevMode &&
assertNotEqual(viewData[viewData[BINDING_INDEX]], NO_CHANGE, 'Stored value should never be NO_CHANGE.');
return viewData[viewData[BINDING_INDEX]++];
} | javascript | {
"resource": ""
} |
q26763 | bindingUpdated | train | function bindingUpdated(value) {
ngDevMode && assertNotEqual(value, NO_CHANGE, 'Incoming value should never be NO_CHANGE.');
if (viewData[BINDING_INDEX] === -1)
initBindings();
var bindingIndex = viewData[BINDING_INDEX];
if (bindingIndex >= viewData.length) {
viewData[viewData[BINDING_INDEX]++] = value;
}
else if (isDifferent(viewData[bindingIndex], value)) {
throwErrorIfNoChangesMode(creationMode, checkNoChangesMode, viewData[bindingIndex], value);
viewData[viewData[BINDING_INDEX]++] = value;
}
else {
viewData[BINDING_INDEX]++;
return false;
}
return true;
} | javascript | {
"resource": ""
} |
q26764 | bindingUpdated4 | train | function bindingUpdated4(exp1, exp2, exp3, exp4) {
var different = bindingUpdated2(exp1, exp2);
return bindingUpdated2(exp3, exp4) || different;
} | javascript | {
"resource": ""
} |
q26765 | assertReservedSlotInitialized | train | function assertReservedSlotInitialized(slotOffset, numSlots) {
if (firstTemplatePass) {
var startIndex = tView.bindingStartIndex - slotOffset;
for (var i = 0; i < numSlots; i++) {
assertEqual(viewData[startIndex + i], NO_CHANGE, 'The reserved slots should be set to `NO_CHANGE` on first template pass');
}
}
} | javascript | {
"resource": ""
} |
q26766 | LifecycleHooksFeature | train | function LifecycleHooksFeature(component, def) {
var elementNode = _getComponentHostLElementNode(component);
// Root component is always created at dir index 0
var tView = elementNode.view[TVIEW];
queueInitHooks(0, def.onInit, def.doCheck, tView);
queueLifecycleHooks(elementNode.tNode.flags, tView);
} | javascript | {
"resource": ""
} |
q26767 | getRootContext | train | function getRootContext(component) {
var rootContext = getRootView(component)[CONTEXT];
ngDevMode && assertDefined(rootContext, 'rootContext');
return rootContext;
} | javascript | {
"resource": ""
} |
q26768 | invertObject | train | function invertObject(obj, secondary) {
if (obj == null)
return EMPTY$1;
var newLookup = {};
for (var minifiedKey in obj) {
if (obj.hasOwnProperty(minifiedKey)) {
var publicName = obj[minifiedKey];
var declaredName = publicName;
if (Array.isArray(publicName)) {
declaredName = publicName[1];
publicName = publicName[0];
}
newLookup[publicName] = minifiedKey;
if (secondary) {
(secondary[declaredName] = minifiedKey);
}
}
}
return newLookup;
} | javascript | {
"resource": ""
} |
q26769 | definePipe | train | function definePipe(pipeDef) {
return {
name: pipeDef.name,
factory: pipeDef.factory,
pure: pipeDef.pure !== false,
onDestroy: pipeDef.type.prototype.ngOnDestroy || null
};
} | javascript | {
"resource": ""
} |
q26770 | NgOnChangesFeature | train | function NgOnChangesFeature(definition) {
var declaredToMinifiedInputs = definition.declaredInputs;
var proto = definition.type.prototype;
var _loop_1 = function (declaredName) {
if (declaredToMinifiedInputs.hasOwnProperty(declaredName)) {
var minifiedKey = declaredToMinifiedInputs[declaredName];
var privateMinKey_1 = PRIVATE_PREFIX + minifiedKey;
// Walk the prototype chain to see if we find a property descriptor
// That way we can honor setters and getters that were inherited.
var originalProperty = undefined;
var checkProto = proto;
while (!originalProperty && checkProto &&
Object.getPrototypeOf(checkProto) !== Object.getPrototypeOf(Object.prototype)) {
originalProperty = Object.getOwnPropertyDescriptor(checkProto, minifiedKey);
checkProto = Object.getPrototypeOf(checkProto);
}
var getter = originalProperty && originalProperty.get;
var setter_1 = originalProperty && originalProperty.set;
// create a getter and setter for property
Object.defineProperty(proto, minifiedKey, {
get: getter ||
(setter_1 ? undefined : function () { return this[privateMinKey_1]; }),
set: function (value) {
var simpleChanges = this[PRIVATE_PREFIX];
if (!simpleChanges) {
simpleChanges = {};
// Place where we will store SimpleChanges if there is a change
Object.defineProperty(this, PRIVATE_PREFIX, { value: simpleChanges, writable: true });
}
var isFirstChange = !this.hasOwnProperty(privateMinKey_1);
var currentChange = simpleChanges[declaredName];
if (currentChange) {
currentChange.currentValue = value;
}
else {
simpleChanges[declaredName] =
new SimpleChange(this[privateMinKey_1], value, isFirstChange);
}
if (isFirstChange) {
// Create a place where the actual value will be stored and make it non-enumerable
Object.defineProperty(this, privateMinKey_1, { value: value, writable: true });
}
else {
this[privateMinKey_1] = value;
}
if (setter_1)
setter_1.call(this, value);
}
});
}
};
for (var declaredName in declaredToMinifiedInputs) {
_loop_1(declaredName);
}
// If an onInit hook is defined, it will need to wrap the ngOnChanges call
// so the call order is changes-init-check in creation mode. In subsequent
// change detection runs, only the check wrapper will be called.
if (definition.onInit != null) {
definition.onInit = onChangesWrapper(definition.onInit);
}
definition.doCheck = onChangesWrapper(definition.doCheck);
} | javascript | {
"resource": ""
} |
q26771 | bloomAdd | train | function bloomAdd(injector, type) {
var id = type[NG_ELEMENT_ID];
// Set a unique ID on the directive type, so if something tries to inject the directive,
// we can easily retrieve the ID and hash it into the bloom bit that should be checked.
if (id == null) {
id = type[NG_ELEMENT_ID] = nextNgElementId++;
}
// We only have BLOOM_SIZE (256) slots in our bloom filter (8 buckets * 32 bits each),
// so all unique IDs must be modulo-ed into a number from 0 - 255 to fit into the filter.
// This means that after 255, some directives will share slots, leading to some false positives
// when checking for a directive's presence.
var bloomBit = id % BLOOM_SIZE;
// Create a mask that targets the specific bit associated with the directive.
// JS bit operations are 32 bits, so this will be a number between 2^0 and 2^31, corresponding
// to bit positions 0 - 31 in a 32 bit integer.
var mask = 1 << bloomBit;
// Use the raw bloomBit number to determine which bloom filter bucket we should check
// e.g: bf0 = [0 - 31], bf1 = [32 - 63], bf2 = [64 - 95], bf3 = [96 - 127], etc
if (bloomBit < 128) {
// Then use the mask to flip on the bit (0-31) associated with the directive in that bucket
bloomBit < 64 ? (bloomBit < 32 ? (injector.bf0 |= mask) : (injector.bf1 |= mask)) :
(bloomBit < 96 ? (injector.bf2 |= mask) : (injector.bf3 |= mask));
}
else {
bloomBit < 192 ? (bloomBit < 160 ? (injector.bf4 |= mask) : (injector.bf5 |= mask)) :
(bloomBit < 224 ? (injector.bf6 |= mask) : (injector.bf7 |= mask));
}
} | javascript | {
"resource": ""
} |
q26772 | injectAttribute | train | function injectAttribute(attrNameToInject) {
ngDevMode && assertPreviousIsParent();
var lElement = getPreviousOrParentNode();
ngDevMode && assertNodeType(lElement, 3 /* Element */);
var tElement = lElement.tNode;
ngDevMode && assertDefined(tElement, 'expecting tNode');
var attrs = tElement.attrs;
if (attrs) {
for (var i = 0; i < attrs.length; i = i + 2) {
var attrName = attrs[i];
if (attrName === 1 /* SelectOnly */)
break;
if (attrName == attrNameToInject) {
return attrs[i + 1];
}
}
}
return undefined;
} | javascript | {
"resource": ""
} |
q26773 | getOrCreateHostChangeDetector | train | function getOrCreateHostChangeDetector(currentNode) {
var hostNode = getClosestComponentAncestor(currentNode);
var hostInjector = hostNode.nodeInjector;
var existingRef = hostInjector && hostInjector.changeDetectorRef;
return existingRef ?
existingRef :
new ViewRef$1(hostNode.data, hostNode
.view[DIRECTIVES][hostNode.tNode.flags >> 14 /* DirectiveStartingIndexShift */]);
} | javascript | {
"resource": ""
} |
q26774 | getClosestComponentAncestor | train | function getClosestComponentAncestor(node) {
while (node.tNode.type === 2 /* View */) {
node = node.view[HOST_NODE];
}
return node;
} | javascript | {
"resource": ""
} |
q26775 | getOrCreateInjectable | train | function getOrCreateInjectable(di, token, flags) {
if (flags === void 0) { flags = 0 /* Default */; }
var bloomHash = bloomHashBit(token);
// If the token has a bloom hash, then it is a directive that is public to the injection system
// (diPublic). If there is no hash, fall back to the module injector.
if (bloomHash === null) {
var moduleInjector = getPreviousOrParentNode().view[INJECTOR$1];
var formerInjector = setCurrentInjector(moduleInjector);
try {
return inject(token, flags);
}
finally {
setCurrentInjector(formerInjector);
}
}
else {
var injector = di;
while (injector) {
// Get the closest potential matching injector (upwards in the injector tree) that
// *potentially* has the token.
injector = bloomFindPossibleInjector(injector, bloomHash, flags);
// If no injector is found, we *know* that there is no ancestor injector that contains the
// token, so we abort.
if (!injector) {
break;
}
// At this point, we have an injector which *may* contain the token, so we step through the
// directives associated with the injector's corresponding node to get the directive instance.
var node = injector.node;
var nodeFlags = node.tNode.flags;
var count = nodeFlags & 4095 /* DirectiveCountMask */;
if (count !== 0) {
var start = nodeFlags >> 14 /* DirectiveStartingIndexShift */;
var end = start + count;
var defs = node.view[TVIEW].directives;
for (var i = start; i < end; i++) {
// Get the definition for the directive at this index and, if it is injectable (diPublic),
// and matches the given token, return the directive instance.
var directiveDef = defs[i];
if (directiveDef.type === token && directiveDef.diPublic) {
return node.view[DIRECTIVES][i];
}
}
}
// If we *didn't* find the directive for the token and we are searching the current node's
// injector, it's possible the directive is on this node and hasn't been created yet.
var instance = void 0;
if (injector === di && (instance = searchMatchesQueuedForCreation(node, token))) {
return instance;
}
// The def wasn't found anywhere on this node, so it was a false positive.
// If flags permit, traverse up the tree and continue searching.
if (flags & 2 /* Self */ || flags & 1 /* Host */ && !sameHostView(injector)) {
injector = null;
}
else {
injector = injector.parent;
}
}
}
// No directive was found for the given token.
if (flags & 8 /* Optional */)
return null;
throw new Error("Injector: NOT_FOUND [" + stringify$1(token) + "]");
} | javascript | {
"resource": ""
} |
q26776 | bloomFindPossibleInjector | train | function bloomFindPossibleInjector(startInjector, bloomBit, flags) {
// Create a mask that targets the specific bit associated with the directive we're looking for.
// JS bit operations are 32 bits, so this will be a number between 2^0 and 2^31, corresponding
// to bit positions 0 - 31 in a 32 bit integer.
var mask = 1 << bloomBit;
// Traverse up the injector tree until we find a potential match or until we know there *isn't* a
// match.
var injector = flags & 4 /* SkipSelf */ ? startInjector.parent : startInjector;
while (injector) {
// Our bloom filter size is 256 bits, which is eight 32-bit bloom filter buckets:
// bf0 = [0 - 31], bf1 = [32 - 63], bf2 = [64 - 95], bf3 = [96 - 127], etc.
// Get the bloom filter value from the appropriate bucket based on the directive's bloomBit.
var value = void 0;
if (bloomBit < 128) {
value = bloomBit < 64 ? (bloomBit < 32 ? injector.bf0 : injector.bf1) :
(bloomBit < 96 ? injector.bf2 : injector.bf3);
}
else {
value = bloomBit < 192 ? (bloomBit < 160 ? injector.bf4 : injector.bf5) :
(bloomBit < 224 ? injector.bf6 : injector.bf7);
}
// If the bloom filter value has the bit corresponding to the directive's bloomBit flipped on,
// this injector is a potential match.
if ((value & mask) === mask) {
return injector;
}
else if (flags & 2 /* Self */ || flags & 1 /* Host */ && !sameHostView(injector)) {
return null;
}
// If the current injector does not have the directive, check the bloom filters for the ancestor
// injectors (cbf0 - cbf7). These filters capture *all* ancestor injectors.
if (bloomBit < 128) {
value = bloomBit < 64 ? (bloomBit < 32 ? injector.cbf0 : injector.cbf1) :
(bloomBit < 96 ? injector.cbf2 : injector.cbf3);
}
else {
value = bloomBit < 192 ? (bloomBit < 160 ? injector.cbf4 : injector.cbf5) :
(bloomBit < 224 ? injector.cbf6 : injector.cbf7);
}
// If the ancestor bloom filter value has the bit corresponding to the directive, traverse up to
// find the specific injector. If the ancestor bloom filter does not have the bit, we can abort.
injector = (value & mask) ? injector.parent : null;
}
return null;
} | javascript | {
"resource": ""
} |
q26777 | sameHostView | train | function sameHostView(injector) {
return !!injector.parent && injector.parent.node.view === injector.node.view;
} | javascript | {
"resource": ""
} |
q26778 | getOrCreateElementRef | train | function getOrCreateElementRef(di) {
return di.elementRef || (di.elementRef = new ElementRef$1(di.node.native));
} | javascript | {
"resource": ""
} |
q26779 | getOrCreateContainerRef | train | function getOrCreateContainerRef(di) {
if (!di.viewContainerRef) {
var vcRefHost = di.node;
ngDevMode && assertNodeOfPossibleTypes(vcRefHost, 0 /* Container */, 3 /* Element */);
var hostParent = getParentLNode(vcRefHost);
var lContainer = createLContainer(hostParent, vcRefHost.view, true);
var comment = vcRefHost.view[RENDERER].createComment(ngDevMode ? 'container' : '');
var lContainerNode = createLNodeObject(0 /* Container */, vcRefHost.view, hostParent, comment, lContainer, null);
appendChild(hostParent, comment, vcRefHost.view);
if (vcRefHost.queries) {
lContainerNode.queries = vcRefHost.queries.container();
}
var hostTNode = vcRefHost.tNode;
if (!hostTNode.dynamicContainerNode) {
hostTNode.dynamicContainerNode =
createTNode(0 /* Container */, -1, null, null, hostTNode, null);
}
lContainerNode.tNode = hostTNode.dynamicContainerNode;
vcRefHost.dynamicLContainerNode = lContainerNode;
addToViewTree(vcRefHost.view, hostTNode.index, lContainer);
di.viewContainerRef = new ViewContainerRef$1(lContainerNode);
}
return di.viewContainerRef;
} | javascript | {
"resource": ""
} |
q26780 | getOrCreateTemplateRef | train | function getOrCreateTemplateRef(di) {
if (!di.templateRef) {
ngDevMode && assertNodeType(di.node, 0 /* Container */);
var hostNode = di.node;
var hostTNode = hostNode.tNode;
ngDevMode && assertDefined(hostTNode.tViews, 'TView must be allocated');
di.templateRef = new TemplateRef$1(getOrCreateElementRef(di), hostTNode.tViews, getRenderer(), hostNode.data[QUERIES]);
}
return di.templateRef;
} | javascript | {
"resource": ""
} |
q26781 | i18nExpMapping | train | function i18nExpMapping(translation, placeholders) {
var staticText = translation.split(i18nTagRegex);
// odd indexes are placeholders
for (var i = 1; i < staticText.length; i += 2) {
staticText[i] = placeholders[staticText[i]];
}
return staticText;
} | javascript | {
"resource": ""
} |
q26782 | i18nInterpolation1 | train | function i18nInterpolation1(instructions, v0) {
var different = bindingUpdated(v0);
if (!different) {
return NO_CHANGE;
}
var res = '';
for (var i = 0; i < instructions.length; i++) {
// Odd indexes are bindings
if (i & 1) {
res += stringify$1(v0);
}
else {
res += instructions[i];
}
}
return res;
} | javascript | {
"resource": ""
} |
q26783 | i18nInterpolation2 | train | function i18nInterpolation2(instructions, v0, v1) {
var different = bindingUpdated2(v0, v1);
if (!different) {
return NO_CHANGE;
}
var res = '';
for (var i = 0; i < instructions.length; i++) {
// Odd indexes are bindings
if (i & 1) {
// Extract bits
var idx = instructions[i];
var b1 = idx & 1;
// Get the value from the argument vx where x = idx
var value = b1 ? v1 : v0;
res += stringify$1(value);
}
else {
res += instructions[i];
}
}
return res;
} | javascript | {
"resource": ""
} |
q26784 | i18nInterpolation3 | train | function i18nInterpolation3(instructions, v0, v1, v2) {
var different = bindingUpdated2(v0, v1);
different = bindingUpdated(v2) || different;
if (!different) {
return NO_CHANGE;
}
var res = '';
for (var i = 0; i < instructions.length; i++) {
// Odd indexes are bindings
if (i & 1) {
// Extract bits
var idx = instructions[i];
var b2 = idx & 2;
var b1 = idx & 1;
// Get the value from the argument vx where x = idx
var value = b2 ? v2 : (b1 ? v1 : v0);
res += stringify$1(value);
}
else {
res += instructions[i];
}
}
return res;
} | javascript | {
"resource": ""
} |
q26785 | i18nInterpolation4 | train | function i18nInterpolation4(instructions, v0, v1, v2, v3) {
var different = bindingUpdated4(v0, v1, v2, v3);
if (!different) {
return NO_CHANGE;
}
var res = '';
for (var i = 0; i < instructions.length; i++) {
// Odd indexes are bindings
if (i & 1) {
// Extract bits
var idx = instructions[i];
var b2 = idx & 2;
var b1 = idx & 1;
// Get the value from the argument vx where x = idx
var value = b2 ? (b1 ? v3 : v2) : (b1 ? v1 : v0);
res += stringify$1(value);
}
else {
res += instructions[i];
}
}
return res;
} | javascript | {
"resource": ""
} |
q26786 | i18nInterpolation5 | train | function i18nInterpolation5(instructions, v0, v1, v2, v3, v4) {
var different = bindingUpdated4(v0, v1, v2, v3);
different = bindingUpdated(v4) || different;
if (!different) {
return NO_CHANGE;
}
var res = '';
for (var i = 0; i < instructions.length; i++) {
// Odd indexes are bindings
if (i & 1) {
// Extract bits
var idx = instructions[i];
var b4 = idx & 4;
var b2 = idx & 2;
var b1 = idx & 1;
// Get the value from the argument vx where x = idx
var value = b4 ? v4 : (b2 ? (b1 ? v3 : v2) : (b1 ? v1 : v0));
res += stringify$1(value);
}
else {
res += instructions[i];
}
}
return res;
} | javascript | {
"resource": ""
} |
q26787 | i18nInterpolation6 | train | function i18nInterpolation6(instructions, v0, v1, v2, v3, v4, v5) {
var different = bindingUpdated4(v0, v1, v2, v3);
different = bindingUpdated2(v4, v5) || different;
if (!different) {
return NO_CHANGE;
}
var res = '';
for (var i = 0; i < instructions.length; i++) {
// Odd indexes are bindings
if (i & 1) {
// Extract bits
var idx = instructions[i];
var b4 = idx & 4;
var b2 = idx & 2;
var b1 = idx & 1;
// Get the value from the argument vx where x = idx
var value = b4 ? (b1 ? v5 : v4) : (b2 ? (b1 ? v3 : v2) : (b1 ? v1 : v0));
res += stringify$1(value);
}
else {
res += instructions[i];
}
}
return res;
} | javascript | {
"resource": ""
} |
q26788 | i18nInterpolationV | train | function i18nInterpolationV(instructions, values) {
var different = false;
for (var i = 0; i < values.length; i++) {
// Check if bindings have changed
bindingUpdated(values[i]) && (different = true);
}
if (!different) {
return NO_CHANGE;
}
var res = '';
for (var i = 0; i < instructions.length; i++) {
// Odd indexes are placeholders
if (i & 1) {
res += stringify$1(values[instructions[i]]);
}
else {
res += instructions[i];
}
}
return res;
} | javascript | {
"resource": ""
} |
q26789 | pureFunction1 | train | function pureFunction1(slotOffset, pureFn, exp, thisArg) {
ngDevMode && assertReservedSlotInitialized(slotOffset, 2);
var index = moveBindingIndexToReservedSlot(slotOffset);
var value = bindingUpdated(exp) ?
checkAndUpdateBinding$1(thisArg ? pureFn.call(thisArg, exp) : pureFn(exp)) :
consumeBinding();
restoreBindingIndex(index);
return value;
} | javascript | {
"resource": ""
} |
q26790 | pureFunctionV | train | function pureFunctionV(slotOffset, pureFn, exps, thisArg) {
ngDevMode && assertReservedSlotInitialized(slotOffset, exps.length + 1);
var index = moveBindingIndexToReservedSlot(slotOffset);
var different = false;
for (var i = 0; i < exps.length; i++) {
bindingUpdated(exps[i]) && (different = true);
}
var value = different ? checkAndUpdateBinding$1(pureFn.apply(thisArg, exps)) : consumeBinding();
restoreBindingIndex(index);
return value;
} | javascript | {
"resource": ""
} |
q26791 | getPipeDef | train | function getPipeDef(name, registry) {
if (registry) {
for (var i = 0; i < registry.length; i++) {
var pipeDef = registry[i];
if (name === pipeDef.name) {
return pipeDef;
}
}
}
throw new Error("Pipe with name '" + name + "' not found!");
} | javascript | {
"resource": ""
} |
q26792 | pipeBind1 | train | function pipeBind1(index, slotOffset, v1) {
var pipeInstance = load(index);
return isPure(index) ? pureFunction1(slotOffset, pipeInstance.transform, v1, pipeInstance) :
pipeInstance.transform(v1);
} | javascript | {
"resource": ""
} |
q26793 | pipeBind2 | train | function pipeBind2(index, slotOffset, v1, v2) {
var pipeInstance = load(index);
return isPure(index) ? pureFunction2(slotOffset, pipeInstance.transform, v1, v2, pipeInstance) :
pipeInstance.transform(v1, v2);
} | javascript | {
"resource": ""
} |
q26794 | pipeBind3 | train | function pipeBind3(index, slotOffset, v1, v2, v3) {
var pipeInstance = load(index);
return isPure(index) ?
pureFunction3(slotOffset, pipeInstance.transform, v1, v2, v3, pipeInstance) :
pipeInstance.transform(v1, v2, v3);
} | javascript | {
"resource": ""
} |
q26795 | pipeBind4 | train | function pipeBind4(index, slotOffset, v1, v2, v3, v4) {
var pipeInstance = load(index);
return isPure(index) ?
pureFunction4(slotOffset, pipeInstance.transform, v1, v2, v3, v4, pipeInstance) :
pipeInstance.transform(v1, v2, v3, v4);
} | javascript | {
"resource": ""
} |
q26796 | pipeBindV | train | function pipeBindV(index, slotOffset, values) {
var pipeInstance = load(index);
return isPure(index) ? pureFunctionV(slotOffset, pipeInstance.transform, values, pipeInstance) :
pipeInstance.transform.apply(pipeInstance, values);
} | javascript | {
"resource": ""
} |
q26797 | getIdxOfMatchingDirective | train | function getIdxOfMatchingDirective(node, type) {
var defs = node.view[TVIEW].directives;
var flags = node.tNode.flags;
var count = flags & 4095 /* DirectiveCountMask */;
var start = flags >> 14 /* DirectiveStartingIndexShift */;
var end = start + count;
for (var i = start; i < end; i++) {
var def = defs[i];
if (def.type === type && def.diPublic) {
return i;
}
}
return null;
} | javascript | {
"resource": ""
} |
q26798 | query | train | function query(memoryIndex, predicate, descend, read) {
ngDevMode && assertPreviousIsParent();
var queryList = new QueryList$1();
var queries = getCurrentQueries(LQueries_);
queries.track(queryList, predicate, descend, read);
storeCleanupWithContext(null, queryList, queryList.destroy);
if (memoryIndex != null) {
store(memoryIndex, queryList);
}
return queryList;
} | javascript | {
"resource": ""
} |
q26799 | queryRefresh | train | function queryRefresh(queryList) {
var queryListImpl = queryList;
if (queryList.dirty) {
queryList.reset(queryListImpl._valuesTree);
queryList.notifyOnChanges();
return true;
}
return false;
} | javascript | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.