package.esm2022.src.defer.utils.mjs Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of core Show documentation
Show all versions of core Show documentation
Angular - the core framework
/**
* @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.dev/license
*/
import { assertIndexInDeclRange } from '../render3/assert';
import { HEADER_OFFSET, TVIEW } from '../render3/interfaces/view';
import { getTNode } from '../render3/util/view_utils';
import { assertEqual, throwError } from '../util/assert';
import { DeferBlockState, DeferDependenciesLoadingState, LOADING_AFTER_SLOT, MINIMUM_SLOT, } from './interfaces';
/**
* Calculates a data slot index for defer block info (either static or
* instance-specific), given an index of a defer instruction.
*/
export function getDeferBlockDataIndex(deferBlockIndex) {
// Instance state is located at the *next* position
// after the defer block slot in an LView or TView.data.
return deferBlockIndex + 1;
}
/** Retrieves a defer block state from an LView, given a TNode that represents a block. */
export function getLDeferBlockDetails(lView, tNode) {
const tView = lView[TVIEW];
const slotIndex = getDeferBlockDataIndex(tNode.index);
ngDevMode && assertIndexInDeclRange(tView, slotIndex);
return lView[slotIndex];
}
/** Stores a defer block instance state in LView. */
export function setLDeferBlockDetails(lView, deferBlockIndex, lDetails) {
const tView = lView[TVIEW];
const slotIndex = getDeferBlockDataIndex(deferBlockIndex);
ngDevMode && assertIndexInDeclRange(tView, slotIndex);
lView[slotIndex] = lDetails;
}
/** Retrieves static info about a defer block, given a TView and a TNode that represents a block. */
export function getTDeferBlockDetails(tView, tNode) {
const slotIndex = getDeferBlockDataIndex(tNode.index);
ngDevMode && assertIndexInDeclRange(tView, slotIndex);
return tView.data[slotIndex];
}
/** Stores a defer block static info in `TView.data`. */
export function setTDeferBlockDetails(tView, deferBlockIndex, deferBlockConfig) {
const slotIndex = getDeferBlockDataIndex(deferBlockIndex);
ngDevMode && assertIndexInDeclRange(tView, slotIndex);
tView.data[slotIndex] = deferBlockConfig;
}
export function getTemplateIndexForState(newState, hostLView, tNode) {
const tView = hostLView[TVIEW];
const tDetails = getTDeferBlockDetails(tView, tNode);
switch (newState) {
case DeferBlockState.Complete:
return tDetails.primaryTmplIndex;
case DeferBlockState.Loading:
return tDetails.loadingTmplIndex;
case DeferBlockState.Error:
return tDetails.errorTmplIndex;
case DeferBlockState.Placeholder:
return tDetails.placeholderTmplIndex;
default:
ngDevMode && throwError(`Unexpected defer block state: ${newState}`);
return null;
}
}
/**
* Returns a minimum amount of time that a given state should be rendered for,
* taking into account `minimum` parameter value. If the `minimum` value is
* not specified - returns `null`.
*/
export function getMinimumDurationForState(tDetails, currentState) {
if (currentState === DeferBlockState.Placeholder) {
return tDetails.placeholderBlockConfig?.[MINIMUM_SLOT] ?? null;
}
else if (currentState === DeferBlockState.Loading) {
return tDetails.loadingBlockConfig?.[MINIMUM_SLOT] ?? null;
}
return null;
}
/** Retrieves the value of the `after` parameter on the @loading block. */
export function getLoadingBlockAfter(tDetails) {
return tDetails.loadingBlockConfig?.[LOADING_AFTER_SLOT] ?? null;
}
/**
* Adds downloaded dependencies into a directive or a pipe registry,
* making sure that a dependency doesn't yet exist in the registry.
*/
export function addDepsToRegistry(currentDeps, newDeps) {
if (!currentDeps || currentDeps.length === 0) {
return newDeps;
}
const currentDepSet = new Set(currentDeps);
for (const dep of newDeps) {
currentDepSet.add(dep);
}
// If `currentDeps` is the same length, there were no new deps and can
// return the original array.
return currentDeps.length === currentDepSet.size ? currentDeps : Array.from(currentDepSet);
}
/** Retrieves a TNode that represents main content of a defer block. */
export function getPrimaryBlockTNode(tView, tDetails) {
const adjustedIndex = tDetails.primaryTmplIndex + HEADER_OFFSET;
return getTNode(tView, adjustedIndex);
}
/**
* Asserts whether all dependencies for a defer block are loaded.
* Always run this function (in dev mode) before rendering a defer
* block in completed state.
*/
export function assertDeferredDependenciesLoaded(tDetails) {
assertEqual(tDetails.loadingState, DeferDependenciesLoadingState.COMPLETE, 'Expecting all deferred dependencies to be loaded.');
}
/**
* Determines if a given value matches the expected structure of a defer block
*
* We can safely rely on the primaryTmplIndex because every defer block requires
* that a primary template exists. All the other template options are optional.
*/
export function isTDeferBlockDetails(value) {
return (value !== null &&
typeof value === 'object' &&
typeof value.primaryTmplIndex === 'number');
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/defer/utils.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.dev/license\n */\n\nimport {assertIndexInDeclRange} from '../render3/assert';\nimport {DependencyDef} from '../render3/interfaces/definition';\nimport {TContainerNode, TNode} from '../render3/interfaces/node';\nimport {HEADER_OFFSET, LView, TVIEW, TView} from '../render3/interfaces/view';\nimport {getTNode} from '../render3/util/view_utils';\nimport {assertEqual, throwError} from '../util/assert';\n\nimport {\n  DeferBlockState,\n  DeferDependenciesLoadingState,\n  LDeferBlockDetails,\n  LOADING_AFTER_SLOT,\n  MINIMUM_SLOT,\n  TDeferBlockDetails,\n} from './interfaces';\n\n/**\n * Calculates a data slot index for defer block info (either static or\n * instance-specific), given an index of a defer instruction.\n */\nexport function getDeferBlockDataIndex(deferBlockIndex: number) {\n  // Instance state is located at the *next* position\n  // after the defer block slot in an LView or TView.data.\n  return deferBlockIndex + 1;\n}\n\n/** Retrieves a defer block state from an LView, given a TNode that represents a block. */\nexport function getLDeferBlockDetails(lView: LView, tNode: TNode): LDeferBlockDetails {\n  const tView = lView[TVIEW];\n  const slotIndex = getDeferBlockDataIndex(tNode.index);\n  ngDevMode && assertIndexInDeclRange(tView, slotIndex);\n  return lView[slotIndex];\n}\n\n/** Stores a defer block instance state in LView. */\nexport function setLDeferBlockDetails(\n  lView: LView,\n  deferBlockIndex: number,\n  lDetails: LDeferBlockDetails,\n) {\n  const tView = lView[TVIEW];\n  const slotIndex = getDeferBlockDataIndex(deferBlockIndex);\n  ngDevMode && assertIndexInDeclRange(tView, slotIndex);\n  lView[slotIndex] = lDetails;\n}\n\n/** Retrieves static info about a defer block, given a TView and a TNode that represents a block. */\nexport function getTDeferBlockDetails(tView: TView, tNode: TNode): TDeferBlockDetails {\n  const slotIndex = getDeferBlockDataIndex(tNode.index);\n  ngDevMode && assertIndexInDeclRange(tView, slotIndex);\n  return tView.data[slotIndex] as TDeferBlockDetails;\n}\n\n/** Stores a defer block static info in `TView.data`. */\nexport function setTDeferBlockDetails(\n  tView: TView,\n  deferBlockIndex: number,\n  deferBlockConfig: TDeferBlockDetails,\n) {\n  const slotIndex = getDeferBlockDataIndex(deferBlockIndex);\n  ngDevMode && assertIndexInDeclRange(tView, slotIndex);\n  tView.data[slotIndex] = deferBlockConfig;\n}\n\nexport function getTemplateIndexForState(\n  newState: DeferBlockState,\n  hostLView: LView,\n  tNode: TNode,\n): number | null {\n  const tView = hostLView[TVIEW];\n  const tDetails = getTDeferBlockDetails(tView, tNode);\n\n  switch (newState) {\n    case DeferBlockState.Complete:\n      return tDetails.primaryTmplIndex;\n    case DeferBlockState.Loading:\n      return tDetails.loadingTmplIndex;\n    case DeferBlockState.Error:\n      return tDetails.errorTmplIndex;\n    case DeferBlockState.Placeholder:\n      return tDetails.placeholderTmplIndex;\n    default:\n      ngDevMode && throwError(`Unexpected defer block state: ${newState}`);\n      return null;\n  }\n}\n\n/**\n * Returns a minimum amount of time that a given state should be rendered for,\n * taking into account `minimum` parameter value. If the `minimum` value is\n * not specified - returns `null`.\n */\nexport function getMinimumDurationForState(\n  tDetails: TDeferBlockDetails,\n  currentState: DeferBlockState,\n): number | null {\n  if (currentState === DeferBlockState.Placeholder) {\n    return tDetails.placeholderBlockConfig?.[MINIMUM_SLOT] ?? null;\n  } else if (currentState === DeferBlockState.Loading) {\n    return tDetails.loadingBlockConfig?.[MINIMUM_SLOT] ?? null;\n  }\n  return null;\n}\n\n/** Retrieves the value of the `after` parameter on the @loading block. */\nexport function getLoadingBlockAfter(tDetails: TDeferBlockDetails): number | null {\n  return tDetails.loadingBlockConfig?.[LOADING_AFTER_SLOT] ?? null;\n}\n\n/**\n * Adds downloaded dependencies into a directive or a pipe registry,\n * making sure that a dependency doesn't yet exist in the registry.\n */\nexport function addDepsToRegistry<T extends DependencyDef[]>(currentDeps: T | null, newDeps: T): T {\n  if (!currentDeps || currentDeps.length === 0) {\n    return newDeps;\n  }\n\n  const currentDepSet = new Set(currentDeps);\n  for (const dep of newDeps) {\n    currentDepSet.add(dep);\n  }\n\n  // If `currentDeps` is the same length, there were no new deps and can\n  // return the original array.\n  return currentDeps.length === currentDepSet.size ? currentDeps : (Array.from(currentDepSet) as T);\n}\n\n/** Retrieves a TNode that represents main content of a defer block. */\nexport function getPrimaryBlockTNode(tView: TView, tDetails: TDeferBlockDetails): TContainerNode {\n  const adjustedIndex = tDetails.primaryTmplIndex + HEADER_OFFSET;\n  return getTNode(tView, adjustedIndex) as TContainerNode;\n}\n\n/**\n * Asserts whether all dependencies for a defer block are loaded.\n * Always run this function (in dev mode) before rendering a defer\n * block in completed state.\n */\nexport function assertDeferredDependenciesLoaded(tDetails: TDeferBlockDetails) {\n  assertEqual(\n    tDetails.loadingState,\n    DeferDependenciesLoadingState.COMPLETE,\n    'Expecting all deferred dependencies to be loaded.',\n  );\n}\n\n/**\n * Determines if a given value matches the expected structure of a defer block\n *\n * We can safely rely on the primaryTmplIndex because every defer block requires\n * that a primary template exists. All the other template options are optional.\n */\nexport function isTDeferBlockDetails(value: unknown): value is TDeferBlockDetails {\n  return (\n    value !== null &&\n    typeof value === 'object' &&\n    typeof (value as TDeferBlockDetails).primaryTmplIndex === 'number'\n  );\n}\n"]}