shared-lib-angular 1.0.0 → 1.0.1

package/.jest-cache/jest-transform-cache-9a3a3745ceefdbbde8dc96f3a11cb645-79ef2876fae7ca75eedb2aa53dc48338/00/appconfig_00660af3355c71a72b8aafc720c254bb.map

@@ -1 +0,0 @@
-{"version":3,"names":["cov_226c15fgas","actualCoverage","s","exports","mapConfigServerResponse","setCurrentAppConfig","getCurrentAppConfig","getAppConfig","getAppConfigWithServerData","currentAppConfig","defaultAppConfig","hosts","configServer","authServer","keycloak","localApp","paths","configService","realm","url","frontend","auth","issuer","loginUrl","tokenEndpoint","userinfoEndpoint","logoutUrl","clientId","redirectUri","postLogoutRedirectUri","silentRefreshRedirectUri","scope","authorization","baseUrl","verifyEndpoint","hierarchyEndpoint","environment","production","requireHttps","showDebugInformation","configServerData","f","mappedConfig","configureAuthServer","initializeClientId","initializeRealmMapping","initializeAuthorizationConfig","initializeAuthScope","initializeKeycloakHost","configureLocalAppCallback","initializeHttpsSettings","b","config","protocol","localProtocol","currentOrigin","globalThis","window","location","origin","serverMappedConfig","mergeConfigurations","buildDynamicUrls","base","override","merged"],"sources":["C:\\data\\repos\\code\\rhdh-template-private\\lib-angular\\src\\lib\\config\\app.config.ts"],"sourcesContent":["import { AppConfiguration, ConfigServerResponse } from '../models/app-config.interface';\r\n\r\n// Variable global para almacenar la configuración actual\r\nlet currentAppConfig: AppConfiguration | null = null;\r\n\r\n// Configuración por defecto que puede ser sobrescrita por variables de entorno\r\nexport const defaultAppConfig: AppConfiguration = {\r\n  hosts: {  \r\n    configServer: '__CONFIG_SERVICE_URL__', // Será reemplazado en runtime por env-replace.sh\r\n    authServer: '', //Leido desde Config Server\r\n    keycloak: '',//Leido desde Config Server\r\n    localApp: ''//Leido desde Config Server\r\n  },\r\n  paths: {\r\n    configService: '/api/v1/config/service',\r\n    realm: 'realm-to-create'\r\n  },\r\n  configServer: {\r\n    url: '', // Se construirá dinámicamente\r\n    frontend: 'dinafi-frmk-template-srv' // Identificador del frontend en el config server\r\n  },\r\n  auth: {\r\n    issuer: '', // Se construirá dinámicamente\r\n    loginUrl: '', // Se construirá dinámicamente\r\n    tokenEndpoint: '', // Se construirá dinámicamente\r\n    userinfoEndpoint: '', // Se construirá dinámicamente\r\n    logoutUrl: '', // Se construirá dinámicamente\r\n    clientId: '',\r\n    redirectUri: '', // Se construirá dinámicamente\r\n    postLogoutRedirectUri: '', // Se construirá dinámicamente\r\n    silentRefreshRedirectUri: '', // Se construirá dinámicamente\r\n    scope: 'openid email profile'\r\n  },\r\n  authorization: {\r\n    baseUrl: '',\r\n    verifyEndpoint: '/api/v1/authz/verify-groups',\r\n    hierarchyEndpoint: '/api/v1/authz/hierarchy-by-component-and-groups',\r\n  },\r\n  environment: {\r\n    production: false,\r\n    requireHttps: true,\r\n    showDebugInformation: false\r\n  }\r\n};\r\n\r\n// Función para mapear la configuración del config server a la configuración de la aplicación\r\nexport function mapConfigServerResponse(configServerData: ConfigServerResponse): Partial<AppConfiguration> {\r\n  const mappedConfig: Partial<AppConfiguration> = {};\r\n  \r\n  // Mapear Auth URL\r\n  configureAuthServer();\r\n\r\n  // Mapear client ID\r\n  initializeClientId();\r\n\r\n  // Mapear realm\r\n  initializeRealmMapping();\r\n\r\n  // Mapear URL de autorización (authServer)\r\n  initializeAuthorizationConfig();\r\n\r\n  // Mapear scope de autorización\r\n  initializeAuthScope();\r\n\r\n  // Mapear keycloak URL\r\n  initializeKeycloakHost();\r\n\r\n  // Mapear callback URL (local app host)\r\n  configureLocalAppCallback(); \r\n\r\n  // Mapear callback URL (local app host)\r\n  initializeHttpsSettings(); \r\n\r\n  return mappedConfig;\r\n\r\n  function initializeHttpsSettings() {\r\n    if (configServerData[\"security.url.https\"]) {\r\n      mappedConfig.environment = {\r\n        ...defaultAppConfig.environment,\r\n        ...(mappedConfig.environment || {}),\r\n        requireHttps: configServerData[\"security.url.https\"]\r\n      };\r\n    }\r\n  }\r\n\r\n  function configureLocalAppCallback() {\r\n    if (configServerData[\"security.url.callback\"]) {\r\n      mappedConfig.hosts = {\r\n        ...defaultAppConfig.hosts,\r\n        ...(mappedConfig.hosts || {}),\r\n        localApp: configServerData[\"security.url.callback\"]\r\n      };\r\n    }\r\n  }\r\n\r\n  function initializeKeycloakHost() {\r\n    if (configServerData[\"security.url.keycloak\"]) {\r\n      mappedConfig.hosts = {\r\n        ...defaultAppConfig.hosts,\r\n        ...(mappedConfig.hosts || {}),\r\n        keycloak: configServerData[\"security.url.keycloak\"]\r\n      };\r\n    }\r\n  }\r\n\r\n  function initializeAuthScope() {\r\n    if (configServerData[\"security.scope\"]) {\r\n      mappedConfig.auth = {\r\n        ...defaultAppConfig.auth,\r\n        ...(mappedConfig.auth || {}),\r\n        scope: configServerData[\"security.scope\"]\r\n      };\r\n    }\r\n  }\r\n\r\n  function initializeAuthorizationConfig() {\r\n    if (configServerData[\"security.url.authz\"]) {\r\n      mappedConfig.authorization = {\r\n        ...defaultAppConfig.authorization,\r\n        ...(mappedConfig.authorization || {}),\r\n        baseUrl: configServerData[\"security.url.authz\"]\r\n      };\r\n    }\r\n  }\r\n\r\n  function initializeRealmMapping() {\r\n    if (configServerData[\"security.realm\"]) {\r\n      mappedConfig.paths = {\r\n        ...defaultAppConfig.paths,\r\n        ...(mappedConfig.paths || {}),\r\n        realm: configServerData[\"security.realm\"]\r\n      };\r\n    }\r\n  }\r\n\r\n  function initializeClientId() {\r\n    if (configServerData[\"quarkus.oidc.client-id\"]) {\r\n      mappedConfig.auth = {\r\n        ...defaultAppConfig.auth,\r\n        ...(mappedConfig.auth || {}),\r\n        clientId: configServerData[\"quarkus.oidc.client-id\"]\r\n      };\r\n    }\r\n  }\r\n\r\n  function configureAuthServer() {\r\n    if (configServerData[\"security.url.auth\"]) {\r\n      mappedConfig.hosts = {\r\n        ...defaultAppConfig.hosts,\r\n        ...(mappedConfig.hosts || {}),\r\n        authServer: configServerData[\"security.url.auth\"]\r\n      };\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Función para establecer la configuración actual con datos del config server\r\n * Esta función debe ser llamada desde el ConfigService después de cargar la configuración\r\n */\r\nexport function setCurrentAppConfig(configServerData?: ConfigServerResponse): void {\r\n  currentAppConfig = getAppConfigWithServerData(configServerData);\r\n}\r\n\r\n/**\r\n * Función para obtener la configuración actual\r\n * Si no se ha establecido una configuración, devuelve la configuración por defecto\r\n */\r\nexport function getCurrentAppConfig(): AppConfiguration {\r\n  return currentAppConfig || getAppConfig();\r\n}\r\n\r\n// Función para obtener la configuración con posibles sobrescrituras de variables de entorno\r\nexport function getAppConfig(): AppConfiguration {\r\n  const config = { ...defaultAppConfig };\r\n\r\n  // Construir URLs dinámicamente\r\n  const protocol = 'https';\r\n  const localProtocol = config.environment.requireHttps ? 'https' : 'http';\r\n  \r\n  // Config Server URL\r\n  config.configServer.url = `${localProtocol}://${config.hosts.configServer}${config.paths.configService}`;\r\n  \r\n  // Auth URLs\r\n  config.auth.issuer = `${protocol}://${config.hosts.keycloak}/realms/${config.paths.realm}`;\r\n  config.auth.loginUrl = `${protocol}://${config.hosts.keycloak}/realms/${config.paths.realm}/protocol/openid-connect/auth`;\r\n  config.auth.tokenEndpoint = `${localProtocol}://${config.hosts.authServer}/oidc/realm/${config.paths.realm}/protocol/openid-connect/token`;\r\n  config.auth.userinfoEndpoint = `${localProtocol}://${config.hosts.authServer}/oidc/realm/${config.paths.realm}/protocol/openid-connect/userinfo`;\r\n  config.auth.logoutUrl = `${localProtocol}://${config.hosts.authServer}/oidc/realm/${config.paths.realm}/protocol/openid-connect/logout`;\r\n   \r\n  // Redirect URLs (locales)\r\n  const currentOrigin = globalThis.window?.location?.origin ?? config.hosts.localApp;\r\n  config.auth.redirectUri = `${currentOrigin}/login`;\r\n  config.auth.postLogoutRedirectUri = `${currentOrigin}/login`;\r\n  \r\n  // Authorization URL\r\n  config.authorization.baseUrl = `${localProtocol}://${config.authorization.baseUrl}`;\r\n  \r\n  return config;\r\n}\r\n\r\n// Función para obtener la configuración aplicando primero la del config server y luego variables de entorno\r\nexport function getAppConfigWithServerData(configServerData?: ConfigServerResponse): AppConfiguration {\r\n  let config = { ...defaultAppConfig };\r\n  \r\n  // Aplicar configuración del config server si está disponible\r\n  if (configServerData) {\r\n    const serverMappedConfig = mapConfigServerResponse(configServerData);\r\n    config = mergeConfigurations(config, serverMappedConfig);\r\n  }\r\n  \r\n  // Construir URLs dinámicamente\r\n  config = buildDynamicUrls(config);\r\n  \r\n  return config;\r\n}\r\n\r\n// Función auxiliar para fusionar configuraciones\r\nfunction mergeConfigurations(base: AppConfiguration, override: Partial<AppConfiguration>): AppConfiguration {\r\n  const merged = { ...base };\r\n  \r\n  if (override.hosts) {\r\n    merged.hosts = { ...merged.hosts, ...override.hosts };\r\n  }\r\n  if (override.paths) {\r\n    merged.paths = { ...merged.paths, ...override.paths };\r\n  }\r\n  if (override.configServer) {\r\n    merged.configServer = { ...merged.configServer, ...override.configServer };\r\n  }\r\n  if (override.auth) {\r\n    merged.auth = { ...merged.auth, ...override.auth };\r\n  }\r\n  if (override.authorization) {\r\n    merged.authorization = { ...merged.authorization, ...override.authorization };\r\n  }\r\n  if (override.environment) {\r\n    merged.environment = { ...merged.environment, ...override.environment };\r\n  }\r\n  \r\n  return merged;\r\n}\r\n\r\n// Función para construir URLs dinámicamente\r\nfunction buildDynamicUrls(config: AppConfiguration): AppConfiguration {\r\n  const protocol = 'https';\r\n  const localProtocol = config.environment.requireHttps ? 'https' : 'http';\r\n  \r\n  // Config Server URL\r\n  config.configServer.url = `${protocol}://${config.hosts.configServer}${config.paths.configService}`;\r\n  \r\n  // Auth URLs\r\n  config.auth.issuer = `${protocol}://${config.hosts.keycloak}/realms/${config.paths.realm}`;\r\n  config.auth.loginUrl = `${protocol}://${config.hosts.keycloak}/realms/${config.paths.realm}/protocol/openid-connect/auth`;\r\n  config.auth.tokenEndpoint = `${localProtocol}://${config.hosts.authServer}/oidc/realm/${config.paths.realm}/protocol/openid-connect/token`;\r\n  config.auth.userinfoEndpoint = `${localProtocol}://${config.hosts.authServer}/oidc/realm/${config.paths.realm}/protocol/openid-connect/userinfo`;\r\n  config.auth.logoutUrl = `${localProtocol}://${config.hosts.authServer}/oidc/realm/${config.paths.realm}/protocol/openid-connect/logout`;\r\n  \r\n  // Redirect URLs (locales)\r\n  const currentOrigin = globalThis.window?.location?.origin ?? config.hosts.localApp;\r\n  config.auth.redirectUri = `${currentOrigin}/login`;\r\n  config.auth.postLogoutRedirectUri = `${currentOrigin}/login`;\r\n\r\n  // Authorization URL\r\n  config.authorization.baseUrl = `${localProtocol}://${config.authorization.baseUrl}`;\r\n  \r\n  return config;\r\n}\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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","ignoreList":[]}

package/.jest-cache/jest-transform-cache-9a3a3745ceefdbbde8dc96f3a11cb645-79ef2876fae7ca75eedb2aa53dc48338/00/every_00ea673d9604654690cab843fc8d8314

@@ -1,22 +0,0 @@
-8594a637067fc5bcf896667f2bf8e9a0
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.every = void 0;
-var lift_1 = require("../util/lift");
-var OperatorSubscriber_1 = require("./OperatorSubscriber");
-function every(predicate, thisArg) {
-    return lift_1.operate(function (source, subscriber) {
-        var index = 0;
-        source.subscribe(OperatorSubscriber_1.createOperatorSubscriber(subscriber, function (value) {
-            if (!predicate.call(thisArg, value, index++, source)) {
-                subscriber.next(false);
-                subscriber.complete();
-            }
-        }, function () {
-            subscriber.next(true);
-            subscriber.complete();
-        }));
-    });
-}
-exports.every = every;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/.jest-cache/jest-transform-cache-9a3a3745ceefdbbde8dc96f3a11cb645-79ef2876fae7ca75eedb2aa53dc48338/00/every_00ea673d9604654690cab843fc8d8314.map

@@ -1 +0,0 @@
-{"file":"C:\\data\\repos\\code\\rhdh-template-private\\lib-angular\\node_modules\\rxjs\\dist\\cjs\\internal\\operators\\every.js","mappings":"AAAA,YAAY,CAAC;AACb,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC;AACvB,IAAI,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;AACrC,IAAI,oBAAoB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;AAC3D,SAAS,KAAK,CAAC,SAAS,EAAE,OAAO;IAC7B,OAAO,MAAM,CAAC,OAAO,CAAC,UAAU,MAAM,EAAE,UAAU;QAC9C,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,MAAM,CAAC,SAAS,CAAC,oBAAoB,CAAC,wBAAwB,CAAC,UAAU,EAAE,UAAU,KAAK;YACtF,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,MAAM,CAAC,EAAE,CAAC;gBACnD,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBACvB,UAAU,CAAC,QAAQ,EAAE,CAAC;YAC1B,CAAC;QACL,CAAC,EAAE;YACC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACtB,UAAU,CAAC,QAAQ,EAAE,CAAC;QAC1B,CAAC,CAAC,CAAC,CAAC;IACR,CAAC,CAAC,CAAC;AACP,CAAC;AACD,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC","names":[],"sources":["C:\\data\\repos\\code\\rhdh-template-private\\lib-angular\\node_modules\\rxjs\\dist\\cjs\\internal\\operators\\every.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.every = void 0;\nvar lift_1 = require(\"../util/lift\");\nvar OperatorSubscriber_1 = require(\"./OperatorSubscriber\");\nfunction every(predicate, thisArg) {\n    return lift_1.operate(function (source, subscriber) {\n        var index = 0;\n        source.subscribe(OperatorSubscriber_1.createOperatorSubscriber(subscriber, function (value) {\n            if (!predicate.call(thisArg, value, index++, source)) {\n                subscriber.next(false);\n                subscriber.complete();\n            }\n        }, function () {\n            subscriber.next(true);\n            subscriber.complete();\n        }));\n    });\n}\nexports.every = every;\n//# sourceMappingURL=every.js.map"],"version":3}

package/.jest-cache/jest-transform-cache-9a3a3745ceefdbbde8dc96f3a11cb645-79ef2876fae7ca75eedb2aa53dc48338/01/signal_019d00f4a5bdafd54307cfe5834fe796

@@ -1,473 +0,0 @@
-0b7225af041b61765eb1b01f283cb266
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var signal_exports = {};
-__export(signal_exports, {
-  COMPUTING: () => COMPUTING,
-  ERRORED: () => ERRORED,
-  REACTIVE_NODE: () => REACTIVE_NODE,
-  SIGNAL: () => SIGNAL,
-  SIGNAL_NODE: () => SIGNAL_NODE,
-  UNSET: () => UNSET,
-  consumerAfterComputation: () => consumerAfterComputation,
-  consumerBeforeComputation: () => consumerBeforeComputation,
-  consumerDestroy: () => consumerDestroy,
-  consumerMarkDirty: () => consumerMarkDirty,
-  consumerPollProducersForChange: () => consumerPollProducersForChange,
-  createComputed: () => createComputed,
-  createSignal: () => createSignal,
-  defaultEquals: () => defaultEquals,
-  finalizeConsumerAfterComputation: () => finalizeConsumerAfterComputation,
-  getActiveConsumer: () => getActiveConsumer,
-  isInNotificationPhase: () => isInNotificationPhase,
-  isReactive: () => isReactive,
-  producerAccessed: () => producerAccessed,
-  producerIncrementEpoch: () => producerIncrementEpoch,
-  producerMarkClean: () => producerMarkClean,
-  producerNotifyConsumers: () => producerNotifyConsumers,
-  producerUpdateValueVersion: () => producerUpdateValueVersion,
-  producerUpdatesAllowed: () => producerUpdatesAllowed,
-  resetConsumerBeforeComputation: () => resetConsumerBeforeComputation,
-  runPostProducerCreatedFn: () => runPostProducerCreatedFn,
-  runPostSignalSetFn: () => runPostSignalSetFn,
-  setActiveConsumer: () => setActiveConsumer,
-  setPostProducerCreatedFn: () => setPostProducerCreatedFn,
-  setPostSignalSetFn: () => setPostSignalSetFn,
-  setThrowInvalidWriteToSignalError: () => setThrowInvalidWriteToSignalError,
-  signalGetFn: () => signalGetFn,
-  signalSetFn: () => signalSetFn,
-  signalUpdateFn: () => signalUpdateFn
-});
-module.exports = __toCommonJS(signal_exports);
-/**
- * @license Angular v20.3.16
- * (c) 2010-2025 Google LLC. https://angular.dev/
- * License: MIT
- */
-let activeConsumer = null;
-let inNotificationPhase = false;
-let epoch = 1;
-let postProducerCreatedFn = null;
-const SIGNAL = /* @__PURE__ */ Symbol("SIGNAL");
-function setActiveConsumer(consumer) {
-  const prev = activeConsumer;
-  activeConsumer = consumer;
-  return prev;
-}
-function getActiveConsumer() {
-  return activeConsumer;
-}
-function isInNotificationPhase() {
-  return inNotificationPhase;
-}
-function isReactive(value) {
-  return value[SIGNAL] !== void 0;
-}
-const REACTIVE_NODE = {
-  version: 0,
-  lastCleanEpoch: 0,
-  dirty: false,
-  producers: void 0,
-  producersTail: void 0,
-  consumers: void 0,
-  consumersTail: void 0,
-  recomputing: false,
-  consumerAllowSignalWrites: false,
-  consumerIsAlwaysLive: false,
-  kind: "unknown",
-  producerMustRecompute: () => false,
-  producerRecomputeValue: () => {
-  },
-  consumerMarkedDirty: () => {
-  },
-  consumerOnSignalRead: () => {
-  }
-};
-function producerAccessed(node) {
-  if (inNotificationPhase) {
-    throw new Error(typeof ngDevMode !== "undefined" && ngDevMode ? `Assertion error: signal read during notification phase` : "");
-  }
-  if (activeConsumer === null) {
-    return;
-  }
-  activeConsumer.consumerOnSignalRead(node);
-  const prevProducerLink = activeConsumer.producersTail;
-  if (prevProducerLink !== void 0 && prevProducerLink.producer === node) {
-    return;
-  }
-  let nextProducerLink = void 0;
-  const isRecomputing = activeConsumer.recomputing;
-  if (isRecomputing) {
-    nextProducerLink = prevProducerLink !== void 0 ? prevProducerLink.nextProducer : activeConsumer.producers;
-    if (nextProducerLink !== void 0 && nextProducerLink.producer === node) {
-      activeConsumer.producersTail = nextProducerLink;
-      nextProducerLink.lastReadVersion = node.version;
-      return;
-    }
-  }
-  const prevConsumerLink = node.consumersTail;
-  if (prevConsumerLink !== void 0 && prevConsumerLink.consumer === activeConsumer && // However, we have to make sure that the link we've discovered isn't from a node that is incrementally rebuilding its producer list
-  (!isRecomputing || isValidLink(prevConsumerLink, activeConsumer))) {
-    return;
-  }
-  const isLive = consumerIsLive(activeConsumer);
-  const newLink = {
-    producer: node,
-    consumer: activeConsumer,
-    // instead of eagerly destroying the previous link, we delay until we've finished recomputing
-    // the producers list, so that we can destroy all of the old links at once.
-    nextProducer: nextProducerLink,
-    prevConsumer: prevConsumerLink,
-    lastReadVersion: node.version,
-    nextConsumer: void 0
-  };
-  activeConsumer.producersTail = newLink;
-  if (prevProducerLink !== void 0) {
-    prevProducerLink.nextProducer = newLink;
-  } else {
-    activeConsumer.producers = newLink;
-  }
-  if (isLive) {
-    producerAddLiveConsumer(node, newLink);
-  }
-}
-function producerIncrementEpoch() {
-  epoch++;
-}
-function producerUpdateValueVersion(node) {
-  if (consumerIsLive(node) && !node.dirty) {
-    return;
-  }
-  if (!node.dirty && node.lastCleanEpoch === epoch) {
-    return;
-  }
-  if (!node.producerMustRecompute(node) && !consumerPollProducersForChange(node)) {
-    producerMarkClean(node);
-    return;
-  }
-  node.producerRecomputeValue(node);
-  producerMarkClean(node);
-}
-function producerNotifyConsumers(node) {
-  if (node.consumers === void 0) {
-    return;
-  }
-  const prev = inNotificationPhase;
-  inNotificationPhase = true;
-  try {
-    for (let link = node.consumers; link !== void 0; link = link.nextConsumer) {
-      const consumer = link.consumer;
-      if (!consumer.dirty) {
-        consumerMarkDirty(consumer);
-      }
-    }
-  } finally {
-    inNotificationPhase = prev;
-  }
-}
-function producerUpdatesAllowed() {
-  return (activeConsumer == null ? void 0 : activeConsumer.consumerAllowSignalWrites) !== false;
-}
-function consumerMarkDirty(node) {
-  var _a;
-  node.dirty = true;
-  producerNotifyConsumers(node);
-  (_a = node.consumerMarkedDirty) == null ? void 0 : _a.call(node, node);
-}
-function producerMarkClean(node) {
-  node.dirty = false;
-  node.lastCleanEpoch = epoch;
-}
-function consumerBeforeComputation(node) {
-  if (node)
-    resetConsumerBeforeComputation(node);
-  return setActiveConsumer(node);
-}
-function resetConsumerBeforeComputation(node) {
-  node.producersTail = void 0;
-  node.recomputing = true;
-}
-function consumerAfterComputation(node, prevConsumer) {
-  setActiveConsumer(prevConsumer);
-  if (node)
-    finalizeConsumerAfterComputation(node);
-}
-function finalizeConsumerAfterComputation(node) {
-  node.recomputing = false;
-  const producersTail = node.producersTail;
-  let toRemove = producersTail !== void 0 ? producersTail.nextProducer : node.producers;
-  if (toRemove !== void 0) {
-    if (consumerIsLive(node)) {
-      do {
-        toRemove = producerRemoveLiveConsumerLink(toRemove);
-      } while (toRemove !== void 0);
-    }
-    if (producersTail !== void 0) {
-      producersTail.nextProducer = void 0;
-    } else {
-      node.producers = void 0;
-    }
-  }
-}
-function consumerPollProducersForChange(node) {
-  for (let link = node.producers; link !== void 0; link = link.nextProducer) {
-    const producer = link.producer;
-    const seenVersion = link.lastReadVersion;
-    if (seenVersion !== producer.version) {
-      return true;
-    }
-    producerUpdateValueVersion(producer);
-    if (seenVersion !== producer.version) {
-      return true;
-    }
-  }
-  return false;
-}
-function consumerDestroy(node) {
-  if (consumerIsLive(node)) {
-    let link = node.producers;
-    while (link !== void 0) {
-      link = producerRemoveLiveConsumerLink(link);
-    }
-  }
-  node.producers = void 0;
-  node.producersTail = void 0;
-  node.consumers = void 0;
-  node.consumersTail = void 0;
-}
-function producerAddLiveConsumer(node, link) {
-  const consumersTail = node.consumersTail;
-  const wasLive = consumerIsLive(node);
-  if (consumersTail !== void 0) {
-    link.nextConsumer = consumersTail.nextConsumer;
-    consumersTail.nextConsumer = link;
-  } else {
-    link.nextConsumer = void 0;
-    node.consumers = link;
-  }
-  link.prevConsumer = consumersTail;
-  node.consumersTail = link;
-  if (!wasLive) {
-    for (let link2 = node.producers; link2 !== void 0; link2 = link2.nextProducer) {
-      producerAddLiveConsumer(link2.producer, link2);
-    }
-  }
-}
-function producerRemoveLiveConsumerLink(link) {
-  const producer = link.producer;
-  const nextProducer = link.nextProducer;
-  const nextConsumer = link.nextConsumer;
-  const prevConsumer = link.prevConsumer;
-  link.nextConsumer = void 0;
-  link.prevConsumer = void 0;
-  if (nextConsumer !== void 0) {
-    nextConsumer.prevConsumer = prevConsumer;
-  } else {
-    producer.consumersTail = prevConsumer;
-  }
-  if (prevConsumer !== void 0) {
-    prevConsumer.nextConsumer = nextConsumer;
-  } else {
-    producer.consumers = nextConsumer;
-    if (!consumerIsLive(producer)) {
-      let producerLink = producer.producers;
-      while (producerLink !== void 0) {
-        producerLink = producerRemoveLiveConsumerLink(producerLink);
-      }
-    }
-  }
-  return nextProducer;
-}
-function consumerIsLive(node) {
-  return node.consumerIsAlwaysLive || node.consumers !== void 0;
-}
-function runPostProducerCreatedFn(node) {
-  postProducerCreatedFn == null ? void 0 : postProducerCreatedFn(node);
-}
-function setPostProducerCreatedFn(fn) {
-  const prev = postProducerCreatedFn;
-  postProducerCreatedFn = fn;
-  return prev;
-}
-function isValidLink(checkLink, consumer) {
-  const producersTail = consumer.producersTail;
-  if (producersTail !== void 0) {
-    let link = consumer.producers;
-    do {
-      if (link === checkLink) {
-        return true;
-      }
-      if (link === producersTail) {
-        break;
-      }
-      link = link.nextProducer;
-    } while (link !== void 0);
-  }
-  return false;
-}
-function defaultEquals(a, b) {
-  return Object.is(a, b);
-}
-function createComputed(computation, equal) {
-  const node = Object.create(COMPUTED_NODE);
-  node.computation = computation;
-  if (equal !== void 0) {
-    node.equal = equal;
-  }
-  const computed = () => {
-    producerUpdateValueVersion(node);
-    producerAccessed(node);
-    if (node.value === ERRORED) {
-      throw node.error;
-    }
-    return node.value;
-  };
-  computed[SIGNAL] = node;
-  if (typeof ngDevMode !== "undefined" && ngDevMode) {
-    const debugName = node.debugName ? " (" + node.debugName + ")" : "";
-    computed.toString = () => `[Computed${debugName}: ${node.value}]`;
-  }
-  runPostProducerCreatedFn(node);
-  return computed;
-}
-const UNSET = /* @__PURE__ */ Symbol("UNSET");
-const COMPUTING = /* @__PURE__ */ Symbol("COMPUTING");
-const ERRORED = /* @__PURE__ */ Symbol("ERRORED");
-const COMPUTED_NODE = /* @__PURE__ */ (() => {
-  return __spreadProps(__spreadValues({}, REACTIVE_NODE), {
-    value: UNSET,
-    dirty: true,
-    error: null,
-    equal: defaultEquals,
-    kind: "computed",
-    producerMustRecompute(node) {
-      return node.value === UNSET || node.value === COMPUTING;
-    },
-    producerRecomputeValue(node) {
-      if (node.value === COMPUTING) {
-        throw new Error(typeof ngDevMode !== "undefined" && ngDevMode ? "Detected cycle in computations." : "");
-      }
-      const oldValue = node.value;
-      node.value = COMPUTING;
-      const prevConsumer = consumerBeforeComputation(node);
-      let newValue;
-      let wasEqual = false;
-      try {
-        newValue = node.computation();
-        setActiveConsumer(null);
-        wasEqual = oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED && node.equal(oldValue, newValue);
-      } catch (err) {
-        newValue = ERRORED;
-        node.error = err;
-      } finally {
-        consumerAfterComputation(node, prevConsumer);
-      }
-      if (wasEqual) {
-        node.value = oldValue;
-        return;
-      }
-      node.value = newValue;
-      node.version++;
-    }
-  });
-})();
-function defaultThrowError() {
-  throw new Error();
-}
-let throwInvalidWriteToSignalErrorFn = defaultThrowError;
-function throwInvalidWriteToSignalError(node) {
-  throwInvalidWriteToSignalErrorFn(node);
-}
-function setThrowInvalidWriteToSignalError(fn) {
-  throwInvalidWriteToSignalErrorFn = fn;
-}
-let postSignalSetFn = null;
-function createSignal(initialValue, equal) {
-  const node = Object.create(SIGNAL_NODE);
-  node.value = initialValue;
-  if (equal !== void 0) {
-    node.equal = equal;
-  }
-  const getter = (() => signalGetFn(node));
-  getter[SIGNAL] = node;
-  if (typeof ngDevMode !== "undefined" && ngDevMode) {
-    const debugName = node.debugName ? " (" + node.debugName + ")" : "";
-    getter.toString = () => `[Signal${debugName}: ${node.value}]`;
-  }
-  runPostProducerCreatedFn(node);
-  const set = (newValue) => signalSetFn(node, newValue);
-  const update = (updateFn) => signalUpdateFn(node, updateFn);
-  return [getter, set, update];
-}
-function setPostSignalSetFn(fn) {
-  const prev = postSignalSetFn;
-  postSignalSetFn = fn;
-  return prev;
-}
-function signalGetFn(node) {
-  producerAccessed(node);
-  return node.value;
-}
-function signalSetFn(node, newValue) {
-  if (!producerUpdatesAllowed()) {
-    throwInvalidWriteToSignalError(node);
-  }
-  if (!node.equal(node.value, newValue)) {
-    node.value = newValue;
-    signalValueChanged(node);
-  }
-}
-function signalUpdateFn(node, updater) {
-  if (!producerUpdatesAllowed()) {
-    throwInvalidWriteToSignalError(node);
-  }
-  signalSetFn(node, updater(node.value));
-}
-function runPostSignalSetFn(node) {
-  postSignalSetFn == null ? void 0 : postSignalSetFn(node);
-}
-const SIGNAL_NODE = /* @__PURE__ */ (() => {
-  return __spreadProps(__spreadValues({}, REACTIVE_NODE), {
-    equal: defaultEquals,
-    value: void 0,
-    kind: "signal"
-  });
-})();
-function signalValueChanged(node) {
-  node.version++;
-  producerIncrementEpoch();
-  producerNotifyConsumers(node);
-  postSignalSetFn == null ? void 0 : postSignalSetFn(node);
-}

package/.jest-cache/jest-transform-cache-9a3a3745ceefdbbde8dc96f3a11cb645-79ef2876fae7ca75eedb2aa53dc48338/01/signal_019d00f4a5bdafd54307cfe5834fe796.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["C:\\data\\repos\\code\\rhdh-template-private\\lib-angular\\node_modules\\@angular\\core\\fesm2022\\signal.mjs"],
-  "sourcesContent": ["/**\n * @license Angular v20.3.16\n * (c) 2010-2025 Google LLC. https://angular.dev/\n * License: MIT\n */\n\n/**\n * The currently active consumer `ReactiveNode`, if running code in a reactive context.\n *\n * Change this via `setActiveConsumer`.\n */\nlet activeConsumer = null;\nlet inNotificationPhase = false;\n/**\n * Global epoch counter. Incremented whenever a source signal is set.\n */\nlet epoch = 1;\n/**\n * If set, called after a producer `ReactiveNode` is created.\n */\nlet postProducerCreatedFn = null;\n/**\n * Symbol used to tell `Signal`s apart from other functions.\n *\n * This can be used to auto-unwrap signals in various cases, or to auto-wrap non-signal values.\n */\nconst SIGNAL = /* @__PURE__ */ Symbol('SIGNAL');\nfunction setActiveConsumer(consumer) {\n    const prev = activeConsumer;\n    activeConsumer = consumer;\n    return prev;\n}\nfunction getActiveConsumer() {\n    return activeConsumer;\n}\nfunction isInNotificationPhase() {\n    return inNotificationPhase;\n}\nfunction isReactive(value) {\n    return value[SIGNAL] !== undefined;\n}\nconst REACTIVE_NODE = {\n    version: 0,\n    lastCleanEpoch: 0,\n    dirty: false,\n    producers: undefined,\n    producersTail: undefined,\n    consumers: undefined,\n    consumersTail: undefined,\n    recomputing: false,\n    consumerAllowSignalWrites: false,\n    consumerIsAlwaysLive: false,\n    kind: 'unknown',\n    producerMustRecompute: () => false,\n    producerRecomputeValue: () => { },\n    consumerMarkedDirty: () => { },\n    consumerOnSignalRead: () => { },\n};\n/**\n * Called by implementations when a producer's signal is read.\n */\nfunction producerAccessed(node) {\n    if (inNotificationPhase) {\n        throw new Error(typeof ngDevMode !== 'undefined' && ngDevMode\n            ? `Assertion error: signal read during notification phase`\n            : '');\n    }\n    if (activeConsumer === null) {\n        // Accessed outside of a reactive context, so nothing to record.\n        return;\n    }\n    activeConsumer.consumerOnSignalRead(node);\n    const prevProducerLink = activeConsumer.producersTail;\n    // If the last producer we accessed is the same as the current one, we can skip adding a new\n    // link\n    if (prevProducerLink !== undefined && prevProducerLink.producer === node) {\n        return;\n    }\n    let nextProducerLink = undefined;\n    const isRecomputing = activeConsumer.recomputing;\n    if (isRecomputing) {\n        // If we're incrementally rebuilding the producers list, we want to check if the next producer\n        // in the list is the same as the one we're trying to add.\n        // If the previous producer is defined, then the next producer is just the one that follows it.\n        // Otherwise, we should check the head of the producers list (the first node that we accessed the last time this consumer was run).\n        nextProducerLink =\n            prevProducerLink !== undefined ? prevProducerLink.nextProducer : activeConsumer.producers;\n        if (nextProducerLink !== undefined && nextProducerLink.producer === node) {\n            // If the next producer is the same as the one we're trying to add, we can just update the\n            // last read version, update the tail of the producers list of this rerun, and return.\n            activeConsumer.producersTail = nextProducerLink;\n            nextProducerLink.lastReadVersion = node.version;\n            return;\n        }\n    }\n    const prevConsumerLink = node.consumersTail;\n    // If the producer we're accessing already has a link to this consumer, we can skip adding a new\n    // link. This can short circuit the creation of a new link in the case where the consumer reads alternating ReeactiveNodes\n    if (prevConsumerLink !== undefined &&\n        prevConsumerLink.consumer === activeConsumer &&\n        // However, we have to make sure that the link we've discovered isn't from a node that is incrementally rebuilding its producer list\n        (!isRecomputing || isValidLink(prevConsumerLink, activeConsumer))) {\n        // If we found an existing link to the consumer we can just return.\n        return;\n    }\n    // If we got here, it means that we need to create a new link between the producer and the consumer.\n    const isLive = consumerIsLive(activeConsumer);\n    const newLink = {\n        producer: node,\n        consumer: activeConsumer,\n        // instead of eagerly destroying the previous link, we delay until we've finished recomputing\n        // the producers list, so that we can destroy all of the old links at once.\n        nextProducer: nextProducerLink,\n        prevConsumer: prevConsumerLink,\n        lastReadVersion: node.version,\n        nextConsumer: undefined,\n    };\n    activeConsumer.producersTail = newLink;\n    if (prevProducerLink !== undefined) {\n        prevProducerLink.nextProducer = newLink;\n    }\n    else {\n        activeConsumer.producers = newLink;\n    }\n    if (isLive) {\n        producerAddLiveConsumer(node, newLink);\n    }\n}\n/**\n * Increment the global epoch counter.\n *\n * Called by source producers (that is, not computeds) whenever their values change.\n */\nfunction producerIncrementEpoch() {\n    epoch++;\n}\n/**\n * Ensure this producer's `version` is up-to-date.\n */\nfunction producerUpdateValueVersion(node) {\n    if (consumerIsLive(node) && !node.dirty) {\n        // A live consumer will be marked dirty by producers, so a clean state means that its version\n        // is guaranteed to be up-to-date.\n        return;\n    }\n    if (!node.dirty && node.lastCleanEpoch === epoch) {\n        // Even non-live consumers can skip polling if they previously found themselves to be clean at\n        // the current epoch, since their dependencies could not possibly have changed (such a change\n        // would've increased the epoch).\n        return;\n    }\n    if (!node.producerMustRecompute(node) && !consumerPollProducersForChange(node)) {\n        // None of our producers report a change since the last time they were read, so no\n        // recomputation of our value is necessary, and we can consider ourselves clean.\n        producerMarkClean(node);\n        return;\n    }\n    node.producerRecomputeValue(node);\n    // After recomputing the value, we're no longer dirty.\n    producerMarkClean(node);\n}\n/**\n * Propagate a dirty notification to live consumers of this producer.\n */\nfunction producerNotifyConsumers(node) {\n    if (node.consumers === undefined) {\n        return;\n    }\n    // Prevent signal reads when we're updating the graph\n    const prev = inNotificationPhase;\n    inNotificationPhase = true;\n    try {\n        for (let link = node.consumers; link !== undefined; link = link.nextConsumer) {\n            const consumer = link.consumer;\n            if (!consumer.dirty) {\n                consumerMarkDirty(consumer);\n            }\n        }\n    }\n    finally {\n        inNotificationPhase = prev;\n    }\n}\n/**\n * Whether this `ReactiveNode` in its producer capacity is currently allowed to initiate updates,\n * based on the current consumer context.\n */\nfunction producerUpdatesAllowed() {\n    return activeConsumer?.consumerAllowSignalWrites !== false;\n}\nfunction consumerMarkDirty(node) {\n    node.dirty = true;\n    producerNotifyConsumers(node);\n    node.consumerMarkedDirty?.(node);\n}\nfunction producerMarkClean(node) {\n    node.dirty = false;\n    node.lastCleanEpoch = epoch;\n}\n/**\n * Prepare this consumer to run a computation in its reactive context and set\n * it as the active consumer.\n *\n * Must be called by subclasses which represent reactive computations, before those computations\n * begin.\n */\nfunction consumerBeforeComputation(node) {\n    if (node)\n        resetConsumerBeforeComputation(node);\n    return setActiveConsumer(node);\n}\n/**\n * Prepare this consumer to run a computation in its reactive context.\n *\n * We expose this mainly for code where we manually batch effects into a single\n * consumer. In those cases we may wish to \"reopen\" a consumer multiple times\n * in initial render before finalizing it. Most code should just call\n * `consumerBeforeComputation` instead of calling this directly.\n */\nfunction resetConsumerBeforeComputation(node) {\n    node.producersTail = undefined;\n    node.recomputing = true;\n}\n/**\n * Finalize this consumer's state and set previous consumer as the active consumer after a\n * reactive computation has run.\n *\n * Must be called by subclasses which represent reactive computations, after those computations\n * have finished.\n */\nfunction consumerAfterComputation(node, prevConsumer) {\n    setActiveConsumer(prevConsumer);\n    if (node)\n        finalizeConsumerAfterComputation(node);\n}\n/**\n * Finalize this consumer's state after a reactive computation has run.\n *\n * We expose this mainly for code where we manually batch effects into a single\n * consumer. In those cases we may wish to \"reopen\" a consumer multiple times\n * in initial render before finalizing it. Most code should just call\n * `consumerAfterComputation` instead of calling this directly.\n */\nfunction finalizeConsumerAfterComputation(node) {\n    node.recomputing = false;\n    // We've finished incrementally rebuilding the producers list, now if there are any producers\n    // that are after producersTail, they are stale and should be removed.\n    const producersTail = node.producersTail;\n    let toRemove = producersTail !== undefined ? producersTail.nextProducer : node.producers;\n    if (toRemove !== undefined) {\n        if (consumerIsLive(node)) {\n            // For each stale link, we first unlink it from the producers list of consumers\n            do {\n                toRemove = producerRemoveLiveConsumerLink(toRemove);\n            } while (toRemove !== undefined);\n        }\n        // Now, we can truncate the producers list to remove all stale links.\n        if (producersTail !== undefined) {\n            producersTail.nextProducer = undefined;\n        }\n        else {\n            node.producers = undefined;\n        }\n    }\n}\n/**\n * Determine whether this consumer has any dependencies which have changed since the last time\n * they were read.\n */\nfunction consumerPollProducersForChange(node) {\n    // Poll producers for change.\n    for (let link = node.producers; link !== undefined; link = link.nextProducer) {\n        const producer = link.producer;\n        const seenVersion = link.lastReadVersion;\n        // First check the versions. A mismatch means that the producer's value is known to have\n        // changed since the last time we read it.\n        if (seenVersion !== producer.version) {\n            return true;\n        }\n        // The producer's version is the same as the last time we read it, but it might itself be\n        // stale. Force the producer to recompute its version (calculating a new value if necessary).\n        producerUpdateValueVersion(producer);\n        // Now when we do this check, `producer.version` is guaranteed to be up to date, so if the\n        // versions still match then it has not changed since the last time we read it.\n        if (seenVersion !== producer.version) {\n            return true;\n        }\n    }\n    return false;\n}\n/**\n * Disconnect this consumer from the graph.\n */\nfunction consumerDestroy(node) {\n    if (consumerIsLive(node)) {\n        // Drop all connections from the graph to this node.\n        let link = node.producers;\n        while (link !== undefined) {\n            link = producerRemoveLiveConsumerLink(link);\n        }\n    }\n    // Truncate all the linked lists to drop all connection from this node to the graph.\n    node.producers = undefined;\n    node.producersTail = undefined;\n    node.consumers = undefined;\n    node.consumersTail = undefined;\n}\n/**\n * Add `consumer` as a live consumer of this node.\n *\n * Note that this operation is potentially transitive. If this node becomes live, then it becomes\n * a live consumer of all of its current producers.\n */\nfunction producerAddLiveConsumer(node, link) {\n    const consumersTail = node.consumersTail;\n    const wasLive = consumerIsLive(node);\n    if (consumersTail !== undefined) {\n        link.nextConsumer = consumersTail.nextConsumer;\n        consumersTail.nextConsumer = link;\n    }\n    else {\n        link.nextConsumer = undefined;\n        node.consumers = link;\n    }\n    link.prevConsumer = consumersTail;\n    node.consumersTail = link;\n    if (!wasLive) {\n        for (let link = node.producers; link !== undefined; link = link.nextProducer) {\n            producerAddLiveConsumer(link.producer, link);\n        }\n    }\n}\nfunction producerRemoveLiveConsumerLink(link) {\n    const producer = link.producer;\n    const nextProducer = link.nextProducer;\n    const nextConsumer = link.nextConsumer;\n    const prevConsumer = link.prevConsumer;\n    link.nextConsumer = undefined;\n    link.prevConsumer = undefined;\n    if (nextConsumer !== undefined) {\n        nextConsumer.prevConsumer = prevConsumer;\n    }\n    else {\n        producer.consumersTail = prevConsumer;\n    }\n    if (prevConsumer !== undefined) {\n        prevConsumer.nextConsumer = nextConsumer;\n    }\n    else {\n        producer.consumers = nextConsumer;\n        if (!consumerIsLive(producer)) {\n            let producerLink = producer.producers;\n            while (producerLink !== undefined) {\n                producerLink = producerRemoveLiveConsumerLink(producerLink);\n            }\n        }\n    }\n    return nextProducer;\n}\nfunction consumerIsLive(node) {\n    return node.consumerIsAlwaysLive || node.consumers !== undefined;\n}\nfunction runPostProducerCreatedFn(node) {\n    postProducerCreatedFn?.(node);\n}\nfunction setPostProducerCreatedFn(fn) {\n    const prev = postProducerCreatedFn;\n    postProducerCreatedFn = fn;\n    return prev;\n}\n// While a ReactiveNode is recomputing, it may not have destroyed previous links\n// This allows us to check if a given link will be destroyed by a reactivenode if it were to finish running immediately without accesing any more producers\nfunction isValidLink(checkLink, consumer) {\n    const producersTail = consumer.producersTail;\n    if (producersTail !== undefined) {\n        let link = consumer.producers;\n        do {\n            if (link === checkLink) {\n                return true;\n            }\n            if (link === producersTail) {\n                break;\n            }\n            link = link.nextProducer;\n        } while (link !== undefined);\n    }\n    return false;\n}\n\n/**\n * The default equality function used for `signal` and `computed`, which uses referential equality.\n */\nfunction defaultEquals(a, b) {\n    return Object.is(a, b);\n}\n\n/**\n * Create a computed signal which derives a reactive value from an expression.\n */\nfunction createComputed(computation, equal) {\n    const node = Object.create(COMPUTED_NODE);\n    node.computation = computation;\n    if (equal !== undefined) {\n        node.equal = equal;\n    }\n    const computed = () => {\n        // Check if the value needs updating before returning it.\n        producerUpdateValueVersion(node);\n        // Record that someone looked at this signal.\n        producerAccessed(node);\n        if (node.value === ERRORED) {\n            throw node.error;\n        }\n        return node.value;\n    };\n    computed[SIGNAL] = node;\n    if (typeof ngDevMode !== 'undefined' && ngDevMode) {\n        const debugName = node.debugName ? ' (' + node.debugName + ')' : '';\n        computed.toString = () => `[Computed${debugName}: ${node.value}]`;\n    }\n    runPostProducerCreatedFn(node);\n    return computed;\n}\n/**\n * A dedicated symbol used before a computed value has been calculated for the first time.\n * Explicitly typed as `any` so we can use it as signal's value.\n */\nconst UNSET = /* @__PURE__ */ Symbol('UNSET');\n/**\n * A dedicated symbol used in place of a computed signal value to indicate that a given computation\n * is in progress. Used to detect cycles in computation chains.\n * Explicitly typed as `any` so we can use it as signal's value.\n */\nconst COMPUTING = /* @__PURE__ */ Symbol('COMPUTING');\n/**\n * A dedicated symbol used in place of a computed signal value to indicate that a given computation\n * failed. The thrown error is cached until the computation gets dirty again.\n * Explicitly typed as `any` so we can use it as signal's value.\n */\nconst ERRORED = /* @__PURE__ */ Symbol('ERRORED');\n// Note: Using an IIFE here to ensure that the spread assignment is not considered\n// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.\n// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.\nconst COMPUTED_NODE = /* @__PURE__ */ (() => {\n    return {\n        ...REACTIVE_NODE,\n        value: UNSET,\n        dirty: true,\n        error: null,\n        equal: defaultEquals,\n        kind: 'computed',\n        producerMustRecompute(node) {\n            // Force a recomputation if there's no current value, or if the current value is in the\n            // process of being calculated (which should throw an error).\n            return node.value === UNSET || node.value === COMPUTING;\n        },\n        producerRecomputeValue(node) {\n            if (node.value === COMPUTING) {\n                // Our computation somehow led to a cyclic read of itself.\n                throw new Error(typeof ngDevMode !== 'undefined' && ngDevMode ? 'Detected cycle in computations.' : '');\n            }\n            const oldValue = node.value;\n            node.value = COMPUTING;\n            const prevConsumer = consumerBeforeComputation(node);\n            let newValue;\n            let wasEqual = false;\n            try {\n                newValue = node.computation();\n                // We want to mark this node as errored if calling `equal` throws; however, we don't want\n                // to track any reactive reads inside `equal`.\n                setActiveConsumer(null);\n                wasEqual =\n                    oldValue !== UNSET &&\n                        oldValue !== ERRORED &&\n                        newValue !== ERRORED &&\n                        node.equal(oldValue, newValue);\n            }\n            catch (err) {\n                newValue = ERRORED;\n                node.error = err;\n            }\n            finally {\n                consumerAfterComputation(node, prevConsumer);\n            }\n            if (wasEqual) {\n                // No change to `valueVersion` - old and new values are\n                // semantically equivalent.\n                node.value = oldValue;\n                return;\n            }\n            node.value = newValue;\n            node.version++;\n        },\n    };\n})();\n\nfunction defaultThrowError() {\n    throw new Error();\n}\nlet throwInvalidWriteToSignalErrorFn = defaultThrowError;\nfunction throwInvalidWriteToSignalError(node) {\n    throwInvalidWriteToSignalErrorFn(node);\n}\nfunction setThrowInvalidWriteToSignalError(fn) {\n    throwInvalidWriteToSignalErrorFn = fn;\n}\n\n/**\n * If set, called after `WritableSignal`s are updated.\n *\n * This hook can be used to achieve various effects, such as running effects synchronously as part\n * of setting a signal.\n */\nlet postSignalSetFn = null;\n/**\n * Creates a `Signal` getter, setter, and updater function.\n */\nfunction createSignal(initialValue, equal) {\n    const node = Object.create(SIGNAL_NODE);\n    node.value = initialValue;\n    if (equal !== undefined) {\n        node.equal = equal;\n    }\n    const getter = (() => signalGetFn(node));\n    getter[SIGNAL] = node;\n    if (typeof ngDevMode !== 'undefined' && ngDevMode) {\n        const debugName = node.debugName ? ' (' + node.debugName + ')' : '';\n        getter.toString = () => `[Signal${debugName}: ${node.value}]`;\n    }\n    runPostProducerCreatedFn(node);\n    const set = (newValue) => signalSetFn(node, newValue);\n    const update = (updateFn) => signalUpdateFn(node, updateFn);\n    return [getter, set, update];\n}\nfunction setPostSignalSetFn(fn) {\n    const prev = postSignalSetFn;\n    postSignalSetFn = fn;\n    return prev;\n}\nfunction signalGetFn(node) {\n    producerAccessed(node);\n    return node.value;\n}\nfunction signalSetFn(node, newValue) {\n    if (!producerUpdatesAllowed()) {\n        throwInvalidWriteToSignalError(node);\n    }\n    if (!node.equal(node.value, newValue)) {\n        node.value = newValue;\n        signalValueChanged(node);\n    }\n}\nfunction signalUpdateFn(node, updater) {\n    if (!producerUpdatesAllowed()) {\n        throwInvalidWriteToSignalError(node);\n    }\n    signalSetFn(node, updater(node.value));\n}\nfunction runPostSignalSetFn(node) {\n    postSignalSetFn?.(node);\n}\n// Note: Using an IIFE here to ensure that the spread assignment is not considered\n// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.\n// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.\nconst SIGNAL_NODE = /* @__PURE__ */ (() => {\n    return {\n        ...REACTIVE_NODE,\n        equal: defaultEquals,\n        value: undefined,\n        kind: 'signal',\n    };\n})();\nfunction signalValueChanged(node) {\n    node.version++;\n    producerIncrementEpoch();\n    producerNotifyConsumers(node);\n    postSignalSetFn?.(node);\n}\n\nexport { COMPUTING, ERRORED, REACTIVE_NODE, SIGNAL, SIGNAL_NODE, UNSET, consumerAfterComputation, consumerBeforeComputation, consumerDestroy, consumerMarkDirty, consumerPollProducersForChange, createComputed, createSignal, defaultEquals, finalizeConsumerAfterComputation, getActiveConsumer, isInNotificationPhase, isReactive, producerAccessed, producerIncrementEpoch, producerMarkClean, producerNotifyConsumers, producerUpdateValueVersion, producerUpdatesAllowed, resetConsumerBeforeComputation, runPostProducerCreatedFn, runPostSignalSetFn, setActiveConsumer, setPostProducerCreatedFn, setPostSignalSetFn, setThrowInvalidWriteToSignalError, signalGetFn, signalSetFn, signalUpdateFn };\n//# sourceMappingURL=signal.mjs.map\n"],
-  "mappings": "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",
-  "names": ["link"]
-}

package/.jest-cache/jest-transform-cache-9a3a3745ceefdbbde8dc96f3a11cb645-79ef2876fae7ca75eedb2aa53dc48338/02/exhaustAll_026083d1cce38f6911e761c16eef3d8a

@@ -1,11 +0,0 @@
-5df298a2cc8e7beb54e42c42f886d6ee
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.exhaustAll = void 0;
-var exhaustMap_1 = require("./exhaustMap");
-var identity_1 = require("../util/identity");
-function exhaustAll() {
-    return exhaustMap_1.exhaustMap(identity_1.identity);
-}
-exports.exhaustAll = exhaustAll;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJmaWxlIjoiQzpcXGRhdGFcXHJlcG9zXFxjb2RlXFxyaGRoLXRlbXBsYXRlLXByaXZhdGVcXGxpYi1hbmd1bGFyXFxub2RlX21vZHVsZXNcXHJ4anNcXGRpc3RcXGNqc1xcaW50ZXJuYWxcXG9wZXJhdG9yc1xcZXhoYXVzdEFsbC5qcyIsIm1hcHBpbmdzIjoiQUFBQSxZQUFZLENBQUM7QUFDYixNQUFNLENBQUMsY0FBYyxDQUFDLE9BQU8sRUFBRSxZQUFZLEVBQUUsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztBQUM5RCxPQUFPLENBQUMsVUFBVSxHQUFHLEtBQUssQ0FBQyxDQUFDO0FBQzVCLElBQUksWUFBWSxHQUFHLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0FBQztBQUMzQyxJQUFJLFVBQVUsR0FBRyxPQUFPLENBQUMsa0JBQWtCLENBQUMsQ0FBQztBQUM3QyxTQUFTLFVBQVU7SUFDZixPQUFPLFlBQVksQ0FBQyxVQUFVLENBQUMsVUFBVSxDQUFDLFFBQVEsQ0FBQyxDQUFDO0FBQ3hELENBQUM7QUFDRCxPQUFPLENBQUMsVUFBVSxHQUFHLFVBQVUsQ0FBQyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyJDOlxcZGF0YVxccmVwb3NcXGNvZGVcXHJoZGgtdGVtcGxhdGUtcHJpdmF0ZVxcbGliLWFuZ3VsYXJcXG5vZGVfbW9kdWxlc1xccnhqc1xcZGlzdFxcY2pzXFxpbnRlcm5hbFxcb3BlcmF0b3JzXFxleGhhdXN0QWxsLmpzIl0sInNvdXJjZXNDb250ZW50IjpbIlwidXNlIHN0cmljdFwiO1xuT2JqZWN0LmRlZmluZVByb3BlcnR5KGV4cG9ydHMsIFwiX19lc01vZHVsZVwiLCB7IHZhbHVlOiB0cnVlIH0pO1xuZXhwb3J0cy5leGhhdXN0QWxsID0gdm9pZCAwO1xudmFyIGV4aGF1c3RNYXBfMSA9IHJlcXVpcmUoXCIuL2V4aGF1c3RNYXBcIik7XG52YXIgaWRlbnRpdHlfMSA9IHJlcXVpcmUoXCIuLi91dGlsL2lkZW50aXR5XCIpO1xuZnVuY3Rpb24gZXhoYXVzdEFsbCgpIHtcbiAgICByZXR1cm4gZXhoYXVzdE1hcF8xLmV4aGF1c3RNYXAoaWRlbnRpdHlfMS5pZGVudGl0eSk7XG59XG5leHBvcnRzLmV4aGF1c3RBbGwgPSBleGhhdXN0QWxsO1xuLy8jIHNvdXJjZU1hcHBpbmdVUkw9ZXhoYXVzdEFsbC5qcy5tYXAiXSwidmVyc2lvbiI6M30=

package/.jest-cache/jest-transform-cache-9a3a3745ceefdbbde8dc96f3a11cb645-79ef2876fae7ca75eedb2aa53dc48338/02/exhaustAll_026083d1cce38f6911e761c16eef3d8a.map

@@ -1 +0,0 @@
-{"file":"C:\\data\\repos\\code\\rhdh-template-private\\lib-angular\\node_modules\\rxjs\\dist\\cjs\\internal\\operators\\exhaustAll.js","mappings":"AAAA,YAAY,CAAC;AACb,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,OAAO,CAAC,UAAU,GAAG,KAAK,CAAC,CAAC;AAC5B,IAAI,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;AAC3C,IAAI,UAAU,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAC7C,SAAS,UAAU;IACf,OAAO,YAAY,CAAC,UAAU,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;AACxD,CAAC;AACD,OAAO,CAAC,UAAU,GAAG,UAAU,CAAC","names":[],"sources":["C:\\data\\repos\\code\\rhdh-template-private\\lib-angular\\node_modules\\rxjs\\dist\\cjs\\internal\\operators\\exhaustAll.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.exhaustAll = void 0;\nvar exhaustMap_1 = require(\"./exhaustMap\");\nvar identity_1 = require(\"../util/identity\");\nfunction exhaustAll() {\n    return exhaustMap_1.exhaustMap(identity_1.identity);\n}\nexports.exhaustAll = exhaustAll;\n//# sourceMappingURL=exhaustAll.js.map"],"version":3}