@angular/core
Version:
Angular - the core framework
133 lines • 18.2 kB
JavaScript
/**
* @license
* Copyright Google LLC 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 { assertEqual, assertGreaterThan, assertGreaterThanOrEqual, throwError, } from '../../util/assert';
import { assertTIcu, assertTNode } from '../assert';
import { createTNodeAtIndex } from '../instructions/shared';
import { assertTNodeType } from '../node_assert';
import { setI18nHandling } from '../node_manipulation';
import { getInsertInFrontOfRNodeWithI18n, processI18nInsertBefore } from '../node_manipulation_i18n';
import { addTNodeAndUpdateInsertBeforeIndex } from './i18n_insert_before_index';
/**
* Retrieve `TIcu` at a given `index`.
*
* The `TIcu` can be stored either directly (if it is nested ICU) OR
* it is stored inside tho `TIcuContainer` if it is top level ICU.
*
* The reason for this is that the top level ICU need a `TNode` so that they are part of the render
* tree, but nested ICU's have no TNode, because we don't know ahead of time if the nested ICU is
* expressed (parent ICU may have selected a case which does not contain it.)
*
* @param tView Current `TView`.
* @param index Index where the value should be read from.
*/
export function getTIcu(tView, index) {
const value = tView.data[index];
if (value === null || typeof value === 'string')
return null;
if (ngDevMode &&
!(value.hasOwnProperty('tView') || value.hasOwnProperty('currentCaseLViewIndex'))) {
throwError("We expect to get 'null'|'TIcu'|'TIcuContainer', but got: " + value);
}
// Here the `value.hasOwnProperty('currentCaseLViewIndex')` is a polymorphic read as it can be
// either TIcu or TIcuContainerNode. This is not ideal, but we still think it is OK because it
// will be just two cases which fits into the browser inline cache (inline cache can take up to
// 4)
const tIcu = value.hasOwnProperty('currentCaseLViewIndex')
? value
: value.value;
ngDevMode && assertTIcu(tIcu);
return tIcu;
}
/**
* Store `TIcu` at a give `index`.
*
* The `TIcu` can be stored either directly (if it is nested ICU) OR
* it is stored inside tho `TIcuContainer` if it is top level ICU.
*
* The reason for this is that the top level ICU need a `TNode` so that they are part of the render
* tree, but nested ICU's have no TNode, because we don't know ahead of time if the nested ICU is
* expressed (parent ICU may have selected a case which does not contain it.)
*
* @param tView Current `TView`.
* @param index Index where the value should be stored at in `Tview.data`
* @param tIcu The TIcu to store.
*/
export function setTIcu(tView, index, tIcu) {
const tNode = tView.data[index];
ngDevMode &&
assertEqual(tNode === null || tNode.hasOwnProperty('tView'), true, "We expect to get 'null'|'TIcuContainer'");
if (tNode === null) {
tView.data[index] = tIcu;
}
else {
ngDevMode && assertTNodeType(tNode, 32 /* TNodeType.Icu */);
tNode.value = tIcu;
}
}
/**
* Set `TNode.insertBeforeIndex` taking the `Array` into account.
*
* See `TNode.insertBeforeIndex`
*/
export function setTNodeInsertBeforeIndex(tNode, index) {
ngDevMode && assertTNode(tNode);
let insertBeforeIndex = tNode.insertBeforeIndex;
if (insertBeforeIndex === null) {
setI18nHandling(getInsertInFrontOfRNodeWithI18n, processI18nInsertBefore);
insertBeforeIndex = tNode.insertBeforeIndex = [
null /* may be updated to number later */,
index,
];
}
else {
assertEqual(Array.isArray(insertBeforeIndex), true, 'Expecting array here');
insertBeforeIndex.push(index);
}
}
/**
* Create `TNode.type=TNodeType.Placeholder` node.
*
* See `TNodeType.Placeholder` for more information.
*/
export function createTNodePlaceholder(tView, previousTNodes, index) {
const tNode = createTNodeAtIndex(tView, index, 64 /* TNodeType.Placeholder */, null, null);
addTNodeAndUpdateInsertBeforeIndex(previousTNodes, tNode);
return tNode;
}
/**
* Returns current ICU case.
*
* ICU cases are stored as index into the `TIcu.cases`.
* At times it is necessary to communicate that the ICU case just switched and that next ICU update
* should update all bindings regardless of the mask. In such a case the we store negative numbers
* for cases which have just been switched. This function removes the negative flag.
*/
export function getCurrentICUCaseIndex(tIcu, lView) {
const currentCase = lView[tIcu.currentCaseLViewIndex];
return currentCase === null ? currentCase : currentCase < 0 ? ~currentCase : currentCase;
}
export function getParentFromIcuCreateOpCode(mergedCode) {
return mergedCode >>> 17 /* IcuCreateOpCode.SHIFT_PARENT */;
}
export function getRefFromIcuCreateOpCode(mergedCode) {
return (mergedCode & 131070 /* IcuCreateOpCode.MASK_REF */) >>> 1 /* IcuCreateOpCode.SHIFT_REF */;
}
export function getInstructionFromIcuCreateOpCode(mergedCode) {
return mergedCode & 1 /* IcuCreateOpCode.MASK_INSTRUCTION */;
}
export function icuCreateOpCode(opCode, parentIdx, refIdx) {
ngDevMode && assertGreaterThanOrEqual(parentIdx, 0, 'Missing parent index');
ngDevMode && assertGreaterThan(refIdx, 0, 'Missing ref index');
return (opCode | (parentIdx << 17 /* IcuCreateOpCode.SHIFT_PARENT */) | (refIdx << 1 /* IcuCreateOpCode.SHIFT_REF */));
}
// Returns whether the given value corresponds to a root template message,
// or a sub-template.
export function isRootTemplateMessage(subTemplateIndex) {
return subTemplateIndex === -1;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"i18n_util.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/i18n/i18n_util.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC 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 {\n  assertEqual,\n  assertGreaterThan,\n  assertGreaterThanOrEqual,\n  throwError,\n} from '../../util/assert';\nimport {assertTIcu, assertTNode} from '../assert';\nimport {createTNodeAtIndex} from '../instructions/shared';\nimport {IcuCreateOpCode, TIcu} from '../interfaces/i18n';\nimport {TIcuContainerNode, TNode, TNodeType} from '../interfaces/node';\nimport {LView, TView} from '../interfaces/view';\nimport {assertTNodeType} from '../node_assert';\nimport {setI18nHandling} from '../node_manipulation';\nimport {getInsertInFrontOfRNodeWithI18n, processI18nInsertBefore} from '../node_manipulation_i18n';\n\nimport {addTNodeAndUpdateInsertBeforeIndex} from './i18n_insert_before_index';\n\n/**\n * Retrieve `TIcu` at a given `index`.\n *\n * The `TIcu` can be stored either directly (if it is nested ICU) OR\n * it is stored inside tho `TIcuContainer` if it is top level ICU.\n *\n * The reason for this is that the top level ICU need a `TNode` so that they are part of the render\n * tree, but nested ICU's have no TNode, because we don't know ahead of time if the nested ICU is\n * expressed (parent ICU may have selected a case which does not contain it.)\n *\n * @param tView Current `TView`.\n * @param index Index where the value should be read from.\n */\nexport function getTIcu(tView: TView, index: number): TIcu | null {\n  const value = tView.data[index] as null | TIcu | TIcuContainerNode | string;\n  if (value === null || typeof value === 'string') return null;\n  if (\n    ngDevMode &&\n    !(value.hasOwnProperty('tView') || value.hasOwnProperty('currentCaseLViewIndex'))\n  ) {\n    throwError(\"We expect to get 'null'|'TIcu'|'TIcuContainer', but got: \" + value);\n  }\n  // Here the `value.hasOwnProperty('currentCaseLViewIndex')` is a polymorphic read as it can be\n  // either TIcu or TIcuContainerNode. This is not ideal, but we still think it is OK because it\n  // will be just two cases which fits into the browser inline cache (inline cache can take up to\n  // 4)\n  const tIcu = value.hasOwnProperty('currentCaseLViewIndex')\n    ? (value as TIcu)\n    : (value as TIcuContainerNode).value;\n  ngDevMode && assertTIcu(tIcu);\n  return tIcu;\n}\n\n/**\n * Store `TIcu` at a give `index`.\n *\n * The `TIcu` can be stored either directly (if it is nested ICU) OR\n * it is stored inside tho `TIcuContainer` if it is top level ICU.\n *\n * The reason for this is that the top level ICU need a `TNode` so that they are part of the render\n * tree, but nested ICU's have no TNode, because we don't know ahead of time if the nested ICU is\n * expressed (parent ICU may have selected a case which does not contain it.)\n *\n * @param tView Current `TView`.\n * @param index Index where the value should be stored at in `Tview.data`\n * @param tIcu The TIcu to store.\n */\nexport function setTIcu(tView: TView, index: number, tIcu: TIcu): void {\n  const tNode = tView.data[index] as null | TIcuContainerNode;\n  ngDevMode &&\n    assertEqual(\n      tNode === null || tNode.hasOwnProperty('tView'),\n      true,\n      \"We expect to get 'null'|'TIcuContainer'\",\n    );\n  if (tNode === null) {\n    tView.data[index] = tIcu;\n  } else {\n    ngDevMode && assertTNodeType(tNode, TNodeType.Icu);\n    tNode.value = tIcu;\n  }\n}\n\n/**\n * Set `TNode.insertBeforeIndex` taking the `Array` into account.\n *\n * See `TNode.insertBeforeIndex`\n */\nexport function setTNodeInsertBeforeIndex(tNode: TNode, index: number) {\n  ngDevMode && assertTNode(tNode);\n  let insertBeforeIndex = tNode.insertBeforeIndex;\n  if (insertBeforeIndex === null) {\n    setI18nHandling(getInsertInFrontOfRNodeWithI18n, processI18nInsertBefore);\n    insertBeforeIndex = tNode.insertBeforeIndex = [\n      null! /* may be updated to number later */,\n      index,\n    ];\n  } else {\n    assertEqual(Array.isArray(insertBeforeIndex), true, 'Expecting array here');\n    (insertBeforeIndex as number[]).push(index);\n  }\n}\n\n/**\n * Create `TNode.type=TNodeType.Placeholder` node.\n *\n * See `TNodeType.Placeholder` for more information.\n */\nexport function createTNodePlaceholder(\n  tView: TView,\n  previousTNodes: TNode[],\n  index: number,\n): TNode {\n  const tNode = createTNodeAtIndex(tView, index, TNodeType.Placeholder, null, null);\n  addTNodeAndUpdateInsertBeforeIndex(previousTNodes, tNode);\n  return tNode;\n}\n\n/**\n * Returns current ICU case.\n *\n * ICU cases are stored as index into the `TIcu.cases`.\n * At times it is necessary to communicate that the ICU case just switched and that next ICU update\n * should update all bindings regardless of the mask. In such a case the we store negative numbers\n * for cases which have just been switched. This function removes the negative flag.\n */\nexport function getCurrentICUCaseIndex(tIcu: TIcu, lView: LView) {\n  const currentCase: number | null = lView[tIcu.currentCaseLViewIndex];\n  return currentCase === null ? currentCase : currentCase < 0 ? ~currentCase : currentCase;\n}\n\nexport function getParentFromIcuCreateOpCode(mergedCode: number): number {\n  return mergedCode >>> IcuCreateOpCode.SHIFT_PARENT;\n}\n\nexport function getRefFromIcuCreateOpCode(mergedCode: number): number {\n  return (mergedCode & IcuCreateOpCode.MASK_REF) >>> IcuCreateOpCode.SHIFT_REF;\n}\n\nexport function getInstructionFromIcuCreateOpCode(mergedCode: number): number {\n  return mergedCode & IcuCreateOpCode.MASK_INSTRUCTION;\n}\n\nexport function icuCreateOpCode(opCode: IcuCreateOpCode, parentIdx: number, refIdx: number) {\n  ngDevMode && assertGreaterThanOrEqual(parentIdx, 0, 'Missing parent index');\n  ngDevMode && assertGreaterThan(refIdx, 0, 'Missing ref index');\n  return (\n    opCode | (parentIdx << IcuCreateOpCode.SHIFT_PARENT) | (refIdx << IcuCreateOpCode.SHIFT_REF)\n  );\n}\n\n// Returns whether the given value corresponds to a root template message,\n// or a sub-template.\nexport function isRootTemplateMessage(subTemplateIndex: number): subTemplateIndex is -1 {\n  return subTemplateIndex === -1;\n}\n"]}