diff --git a/.angular/cache/20.1.6/TFTPaths/.tsbuildinfo b/.angular/cache/20.1.6/TFTPaths/.tsbuildinfo new file mode 100644 index 0000000..dd211b4 --- /dev/null +++ b/.angular/cache/20.1.6/TFTPaths/.tsbuildinfo @@ -0,0 +1 @@ +{"fileNames":["../../../../node_modules/typescript/lib/lib.es5.d.ts","../../../../node_modules/typescript/lib/lib.es2015.d.ts","../../../../node_modules/typescript/lib/lib.es2016.d.ts","../../../../node_modules/typescript/lib/lib.es2017.d.ts","../../../../node_modules/typescript/lib/lib.es2018.d.ts","../../../../node_modules/typescript/lib/lib.dom.d.ts","../../../../node_modules/typescript/lib/lib.es2015.core.d.ts","../../../../node_modules/typescript/lib/lib.es2015.collection.d.ts","../../../../node_modules/typescript/lib/lib.es2015.generator.d.ts","../../../../node_modules/typescript/lib/lib.es2015.iterable.d.ts","../../../../node_modules/typescript/lib/lib.es2015.promise.d.ts","../../../../node_modules/typescript/lib/lib.es2015.proxy.d.ts","../../../../node_modules/typescript/lib/lib.es2015.reflect.d.ts","../../../../node_modules/typescript/lib/lib.es2015.symbol.d.ts","../../../../node_modules/typescript/lib/lib.es2015.symbol.wellknown.d.ts","../../../../node_modules/typescript/lib/lib.es2016.array.include.d.ts","../../../../node_modules/typescript/lib/lib.es2016.intl.d.ts","../../../../node_modules/typescript/lib/lib.es2017.arraybuffer.d.ts","../../../../node_modules/typescript/lib/lib.es2017.date.d.ts","../../../../node_modules/typescript/lib/lib.es2017.object.d.ts","../../../../node_modules/typescript/lib/lib.es2017.sharedmemory.d.ts","../../../../node_modules/typescript/lib/lib.es2017.string.d.ts","../../../../node_modules/typescript/lib/lib.es2017.intl.d.ts","../../../../node_modules/typescript/lib/lib.es2017.typedarrays.d.ts","../../../../node_modules/typescript/lib/lib.es2018.asyncgenerator.d.ts","../../../../node_modules/typescript/lib/lib.es2018.asynciterable.d.ts","../../../../node_modules/typescript/lib/lib.es2018.intl.d.ts","../../../../node_modules/typescript/lib/lib.es2018.promise.d.ts","../../../../node_modules/typescript/lib/lib.es2018.regexp.d.ts","../../../../node_modules/typescript/lib/lib.decorators.d.ts","../../../../node_modules/typescript/lib/lib.decorators.legacy.d.ts","../../../../node_modules/tslib/tslib.d.ts","../../../../node_modules/@angular/core/graph.d.d.ts","../../../../node_modules/@angular/core/event_dispatcher.d.d.ts","../../../../node_modules/@angular/core/chrome_dev_tools_performance.d.d.ts","../../../../node_modules/rxjs/internal/Subscription.d.ts","../../../../node_modules/rxjs/internal/types.d.ts","../../../../node_modules/rxjs/internal/Subscriber.d.ts","../../../../node_modules/rxjs/internal/Operator.d.ts","../../../../node_modules/rxjs/internal/observable/iif.d.ts","../../../../node_modules/rxjs/internal/observable/throwError.d.ts","../../../../node_modules/rxjs/internal/Observable.d.ts","../../../../node_modules/rxjs/internal/Subject.d.ts","../../../../node_modules/rxjs/internal/observable/ConnectableObservable.d.ts","../../../../node_modules/rxjs/internal/operators/groupBy.d.ts","../../../../node_modules/rxjs/internal/symbol/observable.d.ts","../../../../node_modules/rxjs/internal/BehaviorSubject.d.ts","../../../../node_modules/rxjs/internal/ReplaySubject.d.ts","../../../../node_modules/rxjs/internal/AsyncSubject.d.ts","../../../../node_modules/rxjs/internal/Scheduler.d.ts","../../../../node_modules/rxjs/internal/scheduler/Action.d.ts","../../../../node_modules/rxjs/internal/scheduler/AsyncScheduler.d.ts","../../../../node_modules/rxjs/internal/scheduler/AsyncAction.d.ts","../../../../node_modules/rxjs/internal/scheduler/AsapScheduler.d.ts","../../../../node_modules/rxjs/internal/scheduler/asap.d.ts","../../../../node_modules/rxjs/internal/scheduler/async.d.ts","../../../../node_modules/rxjs/internal/scheduler/QueueScheduler.d.ts","../../../../node_modules/rxjs/internal/scheduler/queue.d.ts","../../../../node_modules/rxjs/internal/scheduler/AnimationFrameScheduler.d.ts","../../../../node_modules/rxjs/internal/scheduler/animationFrame.d.ts","../../../../node_modules/rxjs/internal/scheduler/VirtualTimeScheduler.d.ts","../../../../node_modules/rxjs/internal/Notification.d.ts","../../../../node_modules/rxjs/internal/util/pipe.d.ts","../../../../node_modules/rxjs/internal/util/noop.d.ts","../../../../node_modules/rxjs/internal/util/identity.d.ts","../../../../node_modules/rxjs/internal/util/isObservable.d.ts","../../../../node_modules/rxjs/internal/util/ArgumentOutOfRangeError.d.ts","../../../../node_modules/rxjs/internal/util/EmptyError.d.ts","../../../../node_modules/rxjs/internal/util/ObjectUnsubscribedError.d.ts","../../../../node_modules/rxjs/internal/util/UnsubscriptionError.d.ts","../../../../node_modules/rxjs/internal/util/TimeoutError.d.ts","../../../../node_modules/rxjs/internal/observable/bindCallback.d.ts","../../../../node_modules/rxjs/internal/observable/bindNodeCallback.d.ts","../../../../node_modules/rxjs/internal/InnerSubscriber.d.ts","../../../../node_modules/rxjs/internal/OuterSubscriber.d.ts","../../../../node_modules/rxjs/internal/observable/combineLatest.d.ts","../../../../node_modules/rxjs/internal/observable/concat.d.ts","../../../../node_modules/rxjs/internal/observable/defer.d.ts","../../../../node_modules/rxjs/internal/observable/empty.d.ts","../../../../node_modules/rxjs/internal/observable/forkJoin.d.ts","../../../../node_modules/rxjs/internal/observable/from.d.ts","../../../../node_modules/rxjs/internal/observable/fromEvent.d.ts","../../../../node_modules/rxjs/internal/observable/fromEventPattern.d.ts","../../../../node_modules/rxjs/internal/observable/generate.d.ts","../../../../node_modules/rxjs/internal/observable/interval.d.ts","../../../../node_modules/rxjs/internal/observable/merge.d.ts","../../../../node_modules/rxjs/internal/observable/never.d.ts","../../../../node_modules/rxjs/internal/observable/of.d.ts","../../../../node_modules/rxjs/internal/observable/onErrorResumeNext.d.ts","../../../../node_modules/rxjs/internal/observable/pairs.d.ts","../../../../node_modules/rxjs/internal/observable/partition.d.ts","../../../../node_modules/rxjs/internal/observable/race.d.ts","../../../../node_modules/rxjs/internal/observable/range.d.ts","../../../../node_modules/rxjs/internal/observable/timer.d.ts","../../../../node_modules/rxjs/internal/observable/using.d.ts","../../../../node_modules/rxjs/internal/observable/zip.d.ts","../../../../node_modules/rxjs/internal/scheduled/scheduled.d.ts","../../../../node_modules/rxjs/internal/config.d.ts","../../../../node_modules/rxjs/index.d.ts","../../../../node_modules/@angular/core/signal.d.d.ts","../../../../node_modules/@angular/core/primitives/di/index.d.ts","../../../../node_modules/@angular/core/discovery.d.d.ts","../../../../node_modules/@angular/core/api.d.d.ts","../../../../node_modules/@angular/core/weak_ref.d.d.ts","../../../../node_modules/@angular/core/index.d.ts","../../../../node_modules/@angular/platform-browser-dynamic/index.d.ts","../../../../node_modules/@angular/common/platform_location.d.d.ts","../../../../node_modules/@angular/common/common_module.d.d.ts","../../../../node_modules/@angular/common/xhr.d.d.ts","../../../../node_modules/@angular/common/index.d.ts","../../../../node_modules/@angular/platform-browser/browser.d.d.ts","../../../../node_modules/@angular/common/module.d.d.ts","../../../../node_modules/@angular/common/http/index.d.ts","../../../../node_modules/@angular/platform-browser/index.d.ts","../../../../node_modules/@angular/router/router_module.d.d.ts","../../../../node_modules/@angular/router/index.d.ts","../../../../src/modules/layout/components/layout/layout.component.ts","../../../../node_modules/@angular/forms/index.d.ts","../../../../src/models/champion.ts","../../../../src/models/bonus.ts","../../../../src/assets/data/champions.json","../../../../src/assets/data/traits.json","../../../../src/shared/constants.ts","../../../../src/models/dataToShare.ts","../../../../src/modules/pool/services/pool.service.ts","../../../../src/modules/pool/components/pool/pool.component.ts","../../../../src/modules/pool/pool-routing.module.ts","../../../../src/modules/pool/components/card/card.component.ts","../../../../src/modules/pool/pool.module.ts","../../../../src/modules/layout/layout-routing.module.ts","../../../../src/modules/layout/layout.module.ts","../../../../src/app/app-routing.module.ts","../../../../src/app/app.component.ts","../../../../src/app/app.module.ts","../../../../src/environments/environment.ts","../../../../src/main.ts","../../../../node_modules/zone.js/lib/zone-impl.d.ts","../../../../node_modules/zone.js/lib/zone.d.ts","../../../../node_modules/zone.js/lib/zone.api.extensions.d.ts","../../../../node_modules/zone.js/lib/zone.configurations.api.d.ts","../../../../node_modules/zone.js/zone.d.ts","../../../../src/polyfills.ts","../../../../src/app/json-typings.d.ts","../../../../src/environments/environment.prod.ts"],"fileIdsList":[[99,105,107],[99,105,109,112],[99,105,107,108,109],[105],[35],[33,34],[33,34,35,99,100,101],[33,34,35,99,100,101,102,103,104],[33],[99,105],[105,110],[105,110,111,113],[99,105,110,114,115],[99,105,110],[36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,55,56,58,60,61,62,63,64,65,66,67,68,69,70,71,72,73,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98],[36,38,43],[38,75],[37,42],[36,37,38,39,40,41],[37,38],[38,74],[36,37,38,43],[36,37,51],[36,37,38,39,42],[36,37],[37],[36,38,42,43],[37,38,39,42,75],[42],[42,82],[36,37,38,42],[37,38,39,42],[36,37,38,42,43],[99],[36,37,50],[52,53],[36,37,51,52],[36,37,50,51,53],[52],[36,37,52,53],[59],[54],[57],[36,42],[137],[138,139,140],[32,105,116,131],[32,105,114],[32,105,114,132,133],[32],[32,105,106,134,135],[32,119,120],[32,105],[32,105,116,117,129],[32,105,110,117,129,130],[32,105,114,119],[32,99,105,118,119,120,124,125],[32,105,116,126],[32,105,110,118,125,126,127,128],[32,99,105,119,120,123,124],[32,141],[32,119,120,121,122]],"fileInfos":[{"version":"69684132aeb9b5642cbcd9e22dff7818ff0ee1aa831728af0ecf97d3364d5546","affectsGlobalScope":true,"impliedFormat":1},{"version":"45b7ab580deca34ae9729e97c13cfd999df04416a79116c3bfb483804f85ded4","impliedFormat":1},{"version":"3facaf05f0c5fc569c5649dd359892c98a85557e3e0c847964caeb67076f4d75","impliedFormat":1},{"version":"e44bb8bbac7f10ecc786703fe0a6a4b952189f908707980ba8f3c8975a760962","impliedFormat":1},{"version":"5e1c4c362065a6b95ff952c0eab010f04dcd2c3494e813b493ecfd4fcb9fc0d8","impliedFormat":1},{"version":"092c2bfe125ce69dbb1223c85d68d4d2397d7d8411867b5cc03cec902c233763","affectsGlobalScope":true,"impliedFormat":1},{"version":"c57796738e7f83dbc4b8e65132f11a377649c00dd3eee333f672b8f0a6bea671","affectsGlobalScope":true,"impliedFormat":1},{"version":"dc2df20b1bcdc8c2d34af4926e2c3ab15ffe1160a63e58b7e09833f616efff44","affectsGlobalScope":true,"impliedFormat":1},{"version":"515d0b7b9bea2e31ea4ec968e9edd2c39d3eebf4a2d5cbd04e88639819ae3b71","affectsGlobalScope":true,"impliedFormat":1},{"version":"0559b1f683ac7505ae451f9a96ce4c3c92bdc71411651ca6ddb0e88baaaad6a3","affectsGlobalScope":true,"impliedFormat":1},{"version":"0dc1e7ceda9b8b9b455c3a2d67b0412feab00bd2f66656cd8850e8831b08b537","affectsGlobalScope":true,"impliedFormat":1},{"version":"ce691fb9e5c64efb9547083e4a34091bcbe5bdb41027e310ebba8f7d96a98671","affectsGlobalScope":true,"impliedFormat":1},{"version":"8d697a2a929a5fcb38b7a65594020fcef05ec1630804a33748829c5ff53640d0","affectsGlobalScope":true,"impliedFormat":1},{"version":"4ff2a353abf8a80ee399af572debb8faab2d33ad38c4b4474cff7f26e7653b8d","affectsGlobalScope":true,"impliedFormat":1},{"version":"936e80ad36a2ee83fc3caf008e7c4c5afe45b3cf3d5c24408f039c1d47bdc1df","affectsGlobalScope":true,"impliedFormat":1},{"version":"d15bea3d62cbbdb9797079416b8ac375ae99162a7fba5de2c6c505446486ac0a","affectsGlobalScope":true,"impliedFormat":1},{"version":"68d18b664c9d32a7336a70235958b8997ebc1c3b8505f4f1ae2b7e7753b87618","affectsGlobalScope":true,"impliedFormat":1},{"version":"eb3d66c8327153d8fa7dd03f9c58d351107fe824c79e9b56b462935176cdf12a","affectsGlobalScope":true,"impliedFormat":1},{"version":"38f0219c9e23c915ef9790ab1d680440d95419ad264816fa15009a8851e79119","affectsGlobalScope":true,"impliedFormat":1},{"version":"69ab18c3b76cd9b1be3d188eaf8bba06112ebbe2f47f6c322b5105a6fbc45a2e","affectsGlobalScope":true,"impliedFormat":1},{"version":"fef8cfad2e2dc5f5b3d97a6f4f2e92848eb1b88e897bb7318cef0e2820bceaab","affectsGlobalScope":true,"impliedFormat":1},{"version":"2f11ff796926e0832f9ae148008138ad583bd181899ab7dd768a2666700b1893","affectsGlobalScope":true,"impliedFormat":1},{"version":"4de680d5bb41c17f7f68e0419412ca23c98d5749dcaaea1896172f06435891fc","affectsGlobalScope":true,"impliedFormat":1},{"version":"954296b30da6d508a104a3a0b5d96b76495c709785c1d11610908e63481ee667","affectsGlobalScope":true,"impliedFormat":1},{"version":"ac9538681b19688c8eae65811b329d3744af679e0bdfa5d842d0e32524c73e1c","affectsGlobalScope":true,"impliedFormat":1},{"version":"0a969edff4bd52585473d24995c5ef223f6652d6ef46193309b3921d65dd4376","affectsGlobalScope":true,"impliedFormat":1},{"version":"9e9fbd7030c440b33d021da145d3232984c8bb7916f277e8ffd3dc2e3eae2bdb","affectsGlobalScope":true,"impliedFormat":1},{"version":"811ec78f7fefcabbda4bfa93b3eb67d9ae166ef95f9bff989d964061cbf81a0c","affectsGlobalScope":true,"impliedFormat":1},{"version":"717937616a17072082152a2ef351cb51f98802fb4b2fdabd32399843875974ca","affectsGlobalScope":true,"impliedFormat":1},{"version":"8e7f8264d0fb4c5339605a15daadb037bf238c10b654bb3eee14208f860a32ea","affectsGlobalScope":true,"impliedFormat":1},{"version":"782dec38049b92d4e85c1585fbea5474a219c6984a35b004963b00beb1aab538","affectsGlobalScope":true,"impliedFormat":1},{"version":"4576b4e61049f5ffd7c9e935cf88832e089265bdb15ffc35077310042cbbbeea","impliedFormat":1},{"version":"e5385c16de68bdb066fe854b618360221be88b30719f734cc9f2b82d5954d2bf","impliedFormat":99},{"version":"a37b360916ee67e7f6a7068be3852cb13f2917c8b6c16d49f12269c38256e30e","affectsGlobalScope":true,"impliedFormat":99},{"version":"f432ee155d4464fa544a36ec1758411e42e4fe68292376972b0633389ab284b7","affectsGlobalScope":true,"impliedFormat":99},{"version":"6cb35d83d21a7e72bd00398c93302749bcd38349d0cc5e76ff3a90c6d1498a4d","impliedFormat":1},{"version":"369dd7668d0e6c91550bce0c325f37ce6402e5dd40ecfca66fbb5283e23e559d","affectsGlobalScope":true,"impliedFormat":1},{"version":"2632057d8b983ee33295566088c080384d7d69a492bc60b008d6a6dfd3508d6b","impliedFormat":1},{"version":"4bf71cf2a94492fc71e97800bdf2bcb0a9a0fa5fce921c8fe42c67060780cbfa","impliedFormat":1},{"version":"0996ff06f64cb05b6dac158a6ada2e16f8c2ccd20f9ff6f3c3e871f1ba5fb6d9","impliedFormat":1},{"version":"5c492d01a19fea5ebfff9d27e786bc533e5078909521ca17ae41236f16f9686a","impliedFormat":1},{"version":"a6ee930b81c65ec79aca49025b797817dde6f2d2e9b0e0106f0844e18e2cc819","impliedFormat":1},{"version":"84fce15473e993e6b656db9dd3c9196b80f545647458e6621675e840fd700d29","impliedFormat":1},{"version":"7d5336ee766aa72dffb1cc2a515f61d18a4fb61b7a2757cbccfb7b286b783dfb","impliedFormat":1},{"version":"63e96248ab63f6e7a86e31aa3e654ed6de1c3f99e3b668e04800df05874e8b77","impliedFormat":1},{"version":"80da0f61195385d22b666408f6cccbc261c066d401611a286f07dfddf7764017","impliedFormat":1},{"version":"06a20cc7d937074863861ea1159ac783ff97b13952b4b5d1811c7d8ab5c94776","impliedFormat":1},{"version":"ab6de4af0e293eae73b67dad251af097d7bcc0b8b62de84e3674e831514cb056","impliedFormat":1},{"version":"18cbd79079af97af66c9c07c61b481fce14a4e7282eca078c474b40c970ba1d0","impliedFormat":1},{"version":"e7b45405689d87e745a217b648d3646fb47a6aaba9c8d775204de90c7ea9ff35","impliedFormat":1},{"version":"669b754ec246dd7471e19b655b73bda6c2ca5bb7ccb1a4dff44a9ae45b6a716a","impliedFormat":1},{"version":"bcfaca4a8ff50f57fd36df91fba5d34056883f213baff7192cbfc4d3805d2084","impliedFormat":1},{"version":"76a564b360b267502219a89514953058494713ee0923a63b2024e542c18b40e5","impliedFormat":1},{"version":"8f62cbd3afbd6a07bb8c934294b6bfbe437021b89e53a4da7de2648ecfc7af25","impliedFormat":1},{"version":"a20629551ed7923f35f7556c4c15d0c8b2ebe7afaa68ceaab079a1707ba64be2","impliedFormat":1},{"version":"d6de66600c97cd499526ddecea6e12166ab1c0e8d9bf36fb2339fd39c8b3372a","impliedFormat":1},{"version":"8e7a5b8f867b99cc8763c0b024068fb58e09f7da2c4810c12833e1ca6eb11c4f","impliedFormat":1},{"version":"a8932876de2e3138a5a27f9426b225a4d27f0ba0a1e2764ba20930b4c3faf4b9","impliedFormat":1},{"version":"df877050b04c29b9f8409aa10278d586825f511f0841d1ec41b6554f8362092b","impliedFormat":1},{"version":"027d600e00c5f5e1816c207854285d736f2f5fa28276e2829db746d5d6811ba1","impliedFormat":1},{"version":"5443113a16ef378446e08d6500bb48b35de582426459abdb5c9704f5c7d327d9","impliedFormat":1},{"version":"0fb581ecb53304a3c95bb930160b4fa610537470cce850371cbaad5a458ca0d9","impliedFormat":1},{"version":"7da4e290c009d7967343a7f8c3f145a3d2c157c62483362183ba9f637a536489","impliedFormat":1},{"version":"eb21ddc3a8136a12e69176531197def71dc28ffaf357b74d4bf83407bd845991","impliedFormat":1},{"version":"914560d0c4c6aa947cfe7489fe970c94ba25383c414bbe0168b44fd20dbf0df4","impliedFormat":1},{"version":"4fb3405055b54566dea2135845c3a776339e7e170d692401d97fd41ad9a20e5d","impliedFormat":1},{"version":"8d607832a6ef0eac30657173441367dd76c96bf7800d77193428b922e060c3af","impliedFormat":1},{"version":"20ff7207f0bb5cdde5fee8e83315ade7e5b8100cfa2087d20d39069a3d7d06f4","impliedFormat":1},{"version":"7ca4c534eab7cff43d81327e369a23464bc37ef38ce5337ceff24a42c6c84eb2","impliedFormat":1},{"version":"5252dec18a34078398be4e321dee884dc7f47930e5225262543a799b591b36d2","impliedFormat":1},{"version":"23caed4dff98bd28157d2b798b43f1dfefe727f18641648c01ce4e0e929a1630","impliedFormat":1},{"version":"f67e013d5374826596d7c23dbae1cdb14375a27cd72e16c5fb46a4b445059329","impliedFormat":1},{"version":"ea3401b70e2302683bbf4c18b69ef2292b60f4d8f8e6d920413b81fb7bde0f65","impliedFormat":1},{"version":"71afe26642c0fb86b9f8b1af4af5deb5181b43b6542a3ff2314871b53d04c749","impliedFormat":1},{"version":"0d7f01634e6234d84cf0106508efdb8ae00e5ed126eff9606d37b031ac1de654","impliedFormat":1},{"version":"f8d209086bad78af6bd7fef063c1ed449c815e6f8d36058115f222d9f788b848","impliedFormat":1},{"version":"3ad003278d569d1953779e2f838f7798f02e793f6a1eceac8e0065f1a202669b","impliedFormat":1},{"version":"fb2c5eceffcd918dbb86332afa0199f5e7b6cf6ee42809e930a827b28ef25afe","impliedFormat":1},{"version":"f664aaff6a981eeca68f1ff2d9fd21b6664f47bf45f3ae19874df5a6683a8d8a","impliedFormat":1},{"version":"ce066f85d73e09e9adbd0049bcf6471c7eefbfc2ec4b5692b5bcef1e36babd2a","impliedFormat":1},{"version":"09d302513cacfbcc54b67088739bd8ac1c3c57917f83f510b2d1adcb99fd7d2a","impliedFormat":1},{"version":"3faa54e978b92a6f726440c13fe3ab35993dc74d697c7709681dc1764a25219f","impliedFormat":1},{"version":"2bd0489e968925eb0c4c0fb12ef090be5165c86bd088e1e803102c38d4a717d8","impliedFormat":1},{"version":"88924207132b9ba339c1adb1ed3ea07e47b3149ff8a2e21a3ea1f91cee68589d","impliedFormat":1},{"version":"b8800b93d8ab532f8915be73f8195b9d4ef06376d8a82e8cdc17c400553172d6","impliedFormat":1},{"version":"d7d469703b78beba76d511957f8c8b534c3bbb02bea7ab4705c65ef573532fb8","impliedFormat":1},{"version":"74c8c3057669c03264263d911d0f82e876cef50b05be21c54fef23c900de0420","impliedFormat":1},{"version":"b303eda2ff2d582a9c3c5ecb708fb57355cdc25e8c8197a9f66d4d1bf09fda19","impliedFormat":1},{"version":"4e5dc89fa22ff43da3dee1db97d5add0591ebaff9e4adef6c8b6f0b41f0f60f0","impliedFormat":1},{"version":"ec4e82cb42a902fe83dc13153c7a260bee95684541f8d7ef26cb0629a2f4ca31","impliedFormat":1},{"version":"5f36e24cd92b0ff3e2a243685a8a780c9413941c36739f04b428cc4e15de629d","impliedFormat":1},{"version":"40a26494e6ab10a91851791169582ab77fed4fbd799518968177e7eefe08c7a9","impliedFormat":1},{"version":"208e125b45bc561765a74f6f1019d88e44e94678769824cf93726e1bac457961","impliedFormat":1},{"version":"b3985971de086ef3aa698ef19009a53527b72e65851b782dc188ac341a1e1390","impliedFormat":1},{"version":"c81d421aabb6113cd98b9d4f11e9a03273b363b841f294b457f37c15d513151d","impliedFormat":1},{"version":"30063e3a184ff31254bbafa782c78a2d6636943dfe59e1a34f451827fd7a68dc","impliedFormat":1},{"version":"c05d4cae0bceed02c9d013360d3e65658297acb1b7a90252fe366f2bf4f9ccc9","impliedFormat":1},{"version":"6f14b92848889abba03a474e0750f7350cc91fc190c107408ca48679a03975ae","impliedFormat":1},{"version":"a588d0765b1d18bf00a498b75a83e095aef75a9300b6c1e91cbf39e408f2fe2f","impliedFormat":1},{"version":"fec119d1432bd9821ab3d83296b9d97e85eb547e2715aac155ed4a9e8c028c21","impliedFormat":99},{"version":"da081d20b50f7124f3108786efd6b67b299c66a09a4332c6e7a23f11f871756e","impliedFormat":99},{"version":"74c1eba2bf7c62780ae6a81fcc679a806949015c8e20aafb8d7f4fece9622587","impliedFormat":99},{"version":"a7fba861ee9836aa5b07f8d6b6c9e52c12745d861325df23697d5805ba7b683b","impliedFormat":99},{"version":"12e25ed86edf61cad90b23eb31ad194bff7b5c38e109a077dbce323425c0a957","impliedFormat":99},{"version":"8ffaf9b9f57a9a5e1dc1fcf0ad390c9c718e8bec1bde29fc781fa6f290796dfb","impliedFormat":99},{"version":"028a44ea073cc0a3cfd7f1f8e5575ceefac06fa84f72ac0f0a45763a00b46a62","impliedFormat":99},{"version":"320c8b28e4a2dcc7c7fd54db9a82fa39a794a624da7d0b19fa4e19ad0ea15e26","impliedFormat":99},{"version":"a8d51054d8cea3555ef027fa2ed3f6e56f57c7658dd3464ee28eed2d6f84515c","impliedFormat":99},{"version":"d1287eb6b45786e52b191d6ded3a97de3ef4fff04cb751cf2aecc0d453fc055a","impliedFormat":99},{"version":"d4defa7567316728db08a8e62b5b3a2ba46744e20f7c3b6e79f91c5ea28ed099","impliedFormat":99},{"version":"86e1c7230d63bb344ef496868e76d7147887281f24281051ca4bb8eea38a1ced","impliedFormat":99},{"version":"9253b592299534035ece3af87ff76db376c59750611975f92efeff9ab4b184fd","impliedFormat":99},{"version":"8a4f7081a14d09ec6f6879d68659da51b65feaaab4a383a9c503d5e6f0e7a2a1","impliedFormat":99},{"version":"4bac552b94efa2df8ab78160952ab68bc993905363ee8ba080f3b01b783823d8","impliedFormat":99},{"version":"9885565031fb30752fcb805935a74b6967119e79c2fb9b20602aa462f316cccb","impliedFormat":99},{"version":"ec94a868c62347768d23a81ad404d6cc2018b80472028eef0f3007254584caf5","impliedFormat":99},"e2bdab930244283dd3cb9892a96b80ae8033a5afd47458365fbc13d843ae3e72",{"version":"9cff62dd4e61339bac1fa1dfff1c1f1f7f18609ff039246c74a3e80000996a42","impliedFormat":99},"b4335680d9b9c83551a26093f02f8408a23785f6aa871c54c28156bdd24fa39e","0d60a5eebee2d82027f9361a871465a9192dc48e32f1ba8c77fd19cd400abf1d","55d7ad4f1956d842d6047f0f090bbebff3e7d80e99454bb7a19dad6bfa1f17b3","0b494fa9338d955e88fc711767f2af1b438e5dcecf301a52317dda0fc73ce873","1f20fb238077e5da0e8d7c09005d61855fbf8f4e1a3531a3744f1960de6b42de","77b2c69afd4a86293233e0173e0535a1ae1fa4693e73c794d52de6c5e136f11f","2a119e7fbd75b800587ec2323c26ff1821897b80f89c2260084ceb82eb3034dc","2c6d0a2068f1fa4197001ce90a663ce96250406b7c3bcb7f9b402f45b5987a6a","ba780083f324c93c87bf17ac0ec6ed4bc575798962b5ec5a4a375e94e3e00619","eabbac82362fc37f84eef266d51637e008fd2b21fd29de101a12097bf00009d5","8c333c622812c4e58c7674b30b0839cdfe5e95a19698b3db89818ebef7f07f11","a271d01fff89bc79d97a7295eb1d4c29bf60e51c53a0136f7c5fb19a1efd5e5a","3f716fb4a857d4470afe9e8274e58c4ea2d767729eb345679736b953da8a4179","502887bcac8f8d56801fd15c542700cfb461758a0d9764335693557bc76887ae","ff6da71ede48ee84137c23c2005a7d7140d68a52013e3fe64e32eee02a7f0f45","161813a194ce2f4b65b46f15b41263d0ac5b45530e535fc141ef6a02e8b3488a","dc07b8b5ee17d2bdae9a89c3c481afab98a4eb3e14c40614f684657d3511ef52","44bab8ced43078310e1affbf44ca0682f42151082fe1d59a653699697ecabd7d",{"version":"6ff52c2b8704b5419ca72b86fbb3aaba794e7143fe57cdc49042ecdc7a5951cd","impliedFormat":1},{"version":"dc265c71a6e6823017b49104929b065014f689b4dfff724f5a9d6ce8328b19bb","affectsGlobalScope":true,"impliedFormat":1},{"version":"80aac188695136d5ba5cebd0b5786392e783247627b21e6ee048c10a4f9eb938","affectsGlobalScope":true,"impliedFormat":1},{"version":"0f80e8f9529d471302aaee32eb01f01493b81609f91e48aba2bd9cc5040fca75","affectsGlobalScope":true,"impliedFormat":1},{"version":"685bc0a81ae117ea328b7903f6ce188ad7bf5f7789dda7dd226ec841a5dbee02","impliedFormat":1},"23220a766f0662f823cfac5e3c855aebf4a7b0bb025b3dd725a7bc871d2ef4b8","32adb2499044c67c978184af5e4894bc5f9794ae4d714e27e2668017240fdff3","365e9914fc285641a8c9152fa331c83164325564451bd2b05c73859ceaf54a3c"],"root":[117,119,120,[123,136],[142,144]],"options":{"composite":false,"declaration":false,"declarationMap":false,"esModuleInterop":true,"experimentalDecorators":true,"importHelpers":true,"inlineSourceMap":true,"inlineSources":true,"module":99,"noEmitOnError":false,"outDir":"../../../..","removeComments":false,"target":9,"tsBuildInfoFile":"./.tsbuildinfo","useDefineForClassFields":false},"referencedMap":[[108,1],[113,2],[110,3],[112,4],[107,4],[103,5],[35,6],[102,7],[105,8],[100,9],[118,10],[106,4],[111,11],[114,12],[116,13],[115,14],[99,15],[49,16],[47,16],[74,17],[62,18],[42,19],[39,20],[75,21],[48,22],[50,23],[43,24],[38,25],[36,26],[44,27],[72,18],[73,18],[76,28],[77,18],[78,18],[79,18],[80,18],[81,18],[82,29],[83,30],[84,18],[40,18],[85,18],[86,18],[87,29],[88,18],[89,18],[90,31],[91,18],[92,28],[93,18],[41,18],[94,18],[95,18],[96,32],[45,33],[97,34],[51,35],[59,36],[54,36],[53,37],[52,38],[57,39],[61,40],[60,41],[55,42],[56,39],[58,43],[37,44],[66,29],[63,26],[138,45],[141,46],[132,47],[133,48],[134,49],[121,50],[122,50],[144,50],[135,50],[136,51],[120,50],[119,50],[124,52],[117,53],[130,54],[131,55],[128,56],[126,57],[127,58],[129,59],[125,60],[142,61],[123,62]],"semanticDiagnosticsPerFile":[1,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31],"version":"5.8.3"} \ No newline at end of file diff --git a/.angular/cache/20.1.6/TFTPaths/vite/deps/@angular_common.js b/.angular/cache/20.1.6/TFTPaths/vite/deps/@angular_common.js new file mode 100644 index 0000000..4964b4d --- /dev/null +++ b/.angular/cache/20.1.6/TFTPaths/vite/deps/@angular_common.js @@ -0,0 +1,202 @@ +import { + APP_BASE_HREF, + AsyncPipe, + BrowserPlatformLocation, + CommonModule, + CurrencyPipe, + DATE_PIPE_DEFAULT_OPTIONS, + DATE_PIPE_DEFAULT_TIMEZONE, + DatePipe, + DecimalPipe, + DomAdapter, + FormStyle, + FormatWidth, + HashLocationStrategy, + I18nPluralPipe, + I18nSelectPipe, + IMAGE_LOADER, + JsonPipe, + KeyValuePipe, + LOCATION_INITIALIZED, + Location, + LocationStrategy, + LowerCasePipe, + NgClass, + NgComponentOutlet, + NgForOf, + NgForOfContext, + NgIf, + NgIfContext, + NgLocaleLocalization, + NgLocalization, + NgOptimizedImage, + NgPlural, + NgPluralCase, + NgStyle, + NgSwitch, + NgSwitchCase, + NgSwitchDefault, + NgTemplateOutlet, + NullViewportScroller, + NumberFormatStyle, + NumberSymbol, + PLATFORM_BROWSER_ID, + PLATFORM_SERVER_ID, + PRECONNECT_CHECK_BLOCKLIST, + PathLocationStrategy, + PercentPipe, + PlatformLocation, + PlatformNavigation, + Plural, + SlicePipe, + TitleCasePipe, + TranslationWidth, + UpperCasePipe, + VERSION, + ViewportScroller, + WeekDay, + XhrFactory, + formatCurrency, + formatDate, + formatNumber, + formatPercent, + getCurrencySymbol, + getDOM, + getLocaleCurrencyCode, + getLocaleCurrencyName, + getLocaleCurrencySymbol, + getLocaleDateFormat, + getLocaleDateTimeFormat, + getLocaleDayNames, + getLocaleDayPeriods, + getLocaleDirection, + getLocaleEraNames, + getLocaleExtraDayPeriodRules, + getLocaleExtraDayPeriods, + getLocaleFirstDayOfWeek, + getLocaleId, + getLocaleMonthNames, + getLocaleNumberFormat, + getLocaleNumberSymbol, + getLocalePluralCase, + getLocaleTimeFormat, + getLocaleWeekEndRange, + getNumberOfCurrencyDigits, + isPlatformBrowser, + isPlatformServer, + normalizeQueryParams, + parseCookieValue, + provideCloudflareLoader, + provideCloudinaryLoader, + provideImageKitLoader, + provideImgixLoader, + provideNetlifyLoader, + registerLocaleData, + setRootDomAdapter +} from "./chunk-J7WYVKQ5.js"; +import { + DOCUMENT, + IMAGE_CONFIG +} from "./chunk-T7UM462Y.js"; +import "./chunk-6OOPNYDU.js"; +import "./chunk-7PMVITZM.js"; +import "./chunk-3OV72XIM.js"; +export { + APP_BASE_HREF, + AsyncPipe, + BrowserPlatformLocation, + CommonModule, + CurrencyPipe, + DATE_PIPE_DEFAULT_OPTIONS, + DATE_PIPE_DEFAULT_TIMEZONE, + DOCUMENT, + DatePipe, + DecimalPipe, + FormStyle, + FormatWidth, + HashLocationStrategy, + I18nPluralPipe, + I18nSelectPipe, + IMAGE_CONFIG, + IMAGE_LOADER, + JsonPipe, + KeyValuePipe, + LOCATION_INITIALIZED, + Location, + LocationStrategy, + LowerCasePipe, + NgClass, + NgComponentOutlet, + NgForOf as NgFor, + NgForOf, + NgForOfContext, + NgIf, + NgIfContext, + NgLocaleLocalization, + NgLocalization, + NgOptimizedImage, + NgPlural, + NgPluralCase, + NgStyle, + NgSwitch, + NgSwitchCase, + NgSwitchDefault, + NgTemplateOutlet, + NumberFormatStyle, + NumberSymbol, + PRECONNECT_CHECK_BLOCKLIST, + PathLocationStrategy, + PercentPipe, + PlatformLocation, + Plural, + SlicePipe, + TitleCasePipe, + TranslationWidth, + UpperCasePipe, + VERSION, + ViewportScroller, + WeekDay, + XhrFactory, + formatCurrency, + formatDate, + formatNumber, + formatPercent, + getCurrencySymbol, + getLocaleCurrencyCode, + getLocaleCurrencyName, + getLocaleCurrencySymbol, + getLocaleDateFormat, + getLocaleDateTimeFormat, + getLocaleDayNames, + getLocaleDayPeriods, + getLocaleDirection, + getLocaleEraNames, + getLocaleExtraDayPeriodRules, + getLocaleExtraDayPeriods, + getLocaleFirstDayOfWeek, + getLocaleId, + getLocaleMonthNames, + getLocaleNumberFormat, + getLocaleNumberSymbol, + getLocalePluralCase, + getLocaleTimeFormat, + getLocaleWeekEndRange, + getNumberOfCurrencyDigits, + isPlatformBrowser, + isPlatformServer, + provideCloudflareLoader, + provideCloudinaryLoader, + provideImageKitLoader, + provideImgixLoader, + provideNetlifyLoader, + registerLocaleData, + DomAdapter as ɵDomAdapter, + NullViewportScroller as ɵNullViewportScroller, + PLATFORM_BROWSER_ID as ɵPLATFORM_BROWSER_ID, + PLATFORM_SERVER_ID as ɵPLATFORM_SERVER_ID, + PlatformNavigation as ɵPlatformNavigation, + getDOM as ɵgetDOM, + normalizeQueryParams as ɵnormalizeQueryParams, + parseCookieValue as ɵparseCookieValue, + setRootDomAdapter as ɵsetRootDomAdapter +}; diff --git a/.angular/cache/20.1.6/TFTPaths/vite/deps/@angular_common.js.map b/.angular/cache/20.1.6/TFTPaths/vite/deps/@angular_common.js.map new file mode 100644 index 0000000..9865211 --- /dev/null +++ b/.angular/cache/20.1.6/TFTPaths/vite/deps/@angular_common.js.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": [], + "sourcesContent": [], + "mappings": "", + "names": [] +} diff --git a/.angular/cache/20.1.6/TFTPaths/vite/deps/@angular_compiler.js b/.angular/cache/20.1.6/TFTPaths/vite/deps/@angular_compiler.js new file mode 100644 index 0000000..0ecd29b --- /dev/null +++ b/.angular/cache/20.1.6/TFTPaths/vite/deps/@angular_compiler.js @@ -0,0 +1,515 @@ +import { + AST, + ASTWithName, + ASTWithSource, + AbsoluteSourceSpan, + ArrayType, + ArrowFunctionExpr, + Attribute, + Binary, + BinaryOperator, + BinaryOperatorExpr, + BindingPipe, + BindingPipeType, + BindingType, + Block, + BlockNode, + BlockParameter, + BoundAttribute, + BoundDeferredTrigger, + BoundElementProperty, + BoundEvent, + BoundText, + BuiltinType, + BuiltinTypeName, + CUSTOM_ELEMENTS_SCHEMA, + Call, + Chain, + ChangeDetectionStrategy, + CombinedRecursiveAstVisitor, + CommaExpr, + Comment, + CompilerConfig, + CompilerFacadeImpl, + Component, + Component$1, + Conditional, + ConditionalExpr, + ConstantPool, + Content, + CssSelector, + DEFAULT_INTERPOLATION_CONFIG, + DYNAMIC_TYPE, + DeclareFunctionStmt, + DeclareVarStmt, + DeferredBlock, + DeferredBlockError, + DeferredBlockLoading, + DeferredBlockPlaceholder, + DeferredTrigger, + Directive, + Directive$1, + DomElementSchemaRegistry, + DynamicImportExpr, + EOF, + Element, + Element$1, + ElementSchemaRegistry, + EmitterVisitorContext, + EmptyExpr$1, + Expansion, + ExpansionCase, + Expression, + ExpressionBinding, + ExpressionStatement, + ExpressionType, + ExternalExpr, + ExternalReference, + FactoryTarget, + ForLoopBlock, + ForLoopBlockEmpty, + FunctionExpr, + HostElement, + HoverDeferredTrigger, + HtmlParser, + HtmlTagDefinition, + I18NHtmlParser, + Icu$1, + Identifiers, + IdleDeferredTrigger, + IfBlock, + IfBlockBranch, + IfStmt, + ImmediateDeferredTrigger, + ImplicitReceiver, + InstantiateExpr, + InteractionDeferredTrigger, + Interpolation$1, + InterpolationConfig, + InvokeFunctionExpr, + JSDocComment, + JitEvaluator, + KeyedRead, + LeadingComment, + LetDeclaration, + LetDeclaration$1, + Lexer, + LiteralArray, + LiteralArrayExpr, + LiteralExpr, + LiteralMap, + LiteralMapExpr, + LiteralPrimitive, + LocalizedString, + MapType, + MessageBundle, + NONE_TYPE, + NO_ERRORS_SCHEMA, + NeverDeferredTrigger, + NodeWithI18n, + NonNullAssert, + NotExpr, + ParenthesizedExpr, + ParenthesizedExpression, + ParseError, + ParseErrorLevel, + ParseLocation, + ParseSourceFile, + ParseSourceSpan, + ParseSpan, + ParseTreeResult, + ParsedEvent, + ParsedEventType, + ParsedProperty, + ParsedPropertyType, + ParsedVariable, + Parser, + PrefixNot, + PropertyRead, + R3NgModuleMetadataKind, + R3SelectorScopeMode, + R3TargetBinder, + R3TemplateDependencyKind, + ReadKeyExpr, + ReadPropExpr, + ReadVarExpr, + RecursiveAstVisitor, + RecursiveVisitor, + RecursiveVisitor$1, + Reference, + ResourceLoader, + ReturnStatement, + SECURITY_SCHEMA, + STRING_TYPE, + SafeCall, + SafeKeyedRead, + SafePropertyRead, + SelectorContext, + SelectorListContext, + SelectorMatcher, + SelectorlessMatcher, + Serializer, + SplitInterpolation, + Statement, + StmtModifier, + StringToken, + StringTokenKind, + SwitchBlock, + SwitchBlockCase, + TagContentType, + TaggedTemplateLiteral, + TaggedTemplateLiteralExpr, + Template, + TemplateBindingParseResult, + TemplateLiteral, + TemplateLiteralElement, + TemplateLiteralElementExpr, + TemplateLiteralExpr, + Text, + Text$3, + TextAttribute, + ThisReceiver, + TimerDeferredTrigger, + Token, + TokenType, + TransplantedType, + TreeError, + Type, + TypeModifier, + TypeofExpr, + TypeofExpression, + Unary, + UnaryOperator, + UnaryOperatorExpr, + UnknownBlock, + VERSION, + Variable, + VariableBinding, + Version, + ViewEncapsulation$1, + ViewportDeferredTrigger, + VoidExpr, + VoidExpression, + WrappedNodeExpr, + Xliff, + Xliff2, + Xmb, + XmlParser, + Xtb, + compileClassDebugInfo, + compileClassMetadata, + compileComponentClassMetadata, + compileComponentDeclareClassMetadata, + compileComponentFromMetadata, + compileDeclareClassMetadata, + compileDeclareComponentFromMetadata, + compileDeclareDirectiveFromMetadata, + compileDeclareFactoryFunction, + compileDeclareInjectableFromMetadata, + compileDeclareInjectorFromMetadata, + compileDeclareNgModuleFromMetadata, + compileDeclarePipeFromMetadata, + compileDeferResolverFunction, + compileDirectiveFromMetadata, + compileFactoryFunction, + compileHmrInitializer, + compileHmrUpdateCallback, + compileInjectable, + compileInjector, + compileNgModule, + compileOpaqueAsyncClassMetadata, + compilePipeFromMetadata, + computeMsgId, + core, + createCssSelectorFromNode, + createInjectableType, + createMayBeForwardRefExpression, + devOnlyGuardedExpression, + emitDistinctChangesOnlyDefaultValue, + encapsulateStyle, + escapeRegExp, + findMatchingDirectivesAndPipes, + getHtmlTagDefinition, + getNsPrefix, + getSafePropertyAccessString, + identifierName, + isNgContainer, + isNgContent, + isNgTemplate, + jsDocComment, + leadingComment, + literal, + literalMap, + makeBindingParser, + mergeNsAndName, + output_ast, + parseHostBindings, + parseTemplate, + preserveWhitespacesDefault, + publishFacade, + r3JitTypeSourceSpan, + sanitizeIdentifier, + setEnableTemplateSourceLocations, + splitNsName, + verifyHostBindings, + visitAll, + visitAll$1 +} from "./chunk-MIBI5X5V.js"; +import "./chunk-3OV72XIM.js"; +export { + AST, + ASTWithName, + ASTWithSource, + AbsoluteSourceSpan, + ArrayType, + ArrowFunctionExpr, + Attribute, + Binary, + BinaryOperator, + BinaryOperatorExpr, + BindingPipe, + BindingPipeType, + BindingType, + Block, + BlockParameter, + BoundElementProperty, + BuiltinType, + BuiltinTypeName, + CUSTOM_ELEMENTS_SCHEMA, + Call, + Chain, + ChangeDetectionStrategy, + CombinedRecursiveAstVisitor, + CommaExpr, + Comment, + CompilerConfig, + CompilerFacadeImpl, + Component, + Conditional, + ConditionalExpr, + ConstantPool, + CssSelector, + DEFAULT_INTERPOLATION_CONFIG, + DYNAMIC_TYPE, + DeclareFunctionStmt, + DeclareVarStmt, + Directive, + DomElementSchemaRegistry, + DynamicImportExpr, + EOF, + Element, + ElementSchemaRegistry, + EmitterVisitorContext, + EmptyExpr$1 as EmptyExpr, + Expansion, + ExpansionCase, + Expression, + ExpressionBinding, + ExpressionStatement, + ExpressionType, + ExternalExpr, + ExternalReference, + FactoryTarget, + FunctionExpr, + HtmlParser, + HtmlTagDefinition, + I18NHtmlParser, + IfStmt, + ImplicitReceiver, + InstantiateExpr, + Interpolation$1 as Interpolation, + InterpolationConfig, + InvokeFunctionExpr, + JSDocComment, + JitEvaluator, + KeyedRead, + LeadingComment, + LetDeclaration, + Lexer, + LiteralArray, + LiteralArrayExpr, + LiteralExpr, + LiteralMap, + LiteralMapExpr, + LiteralPrimitive, + LocalizedString, + MapType, + MessageBundle, + NONE_TYPE, + NO_ERRORS_SCHEMA, + NodeWithI18n, + NonNullAssert, + NotExpr, + ParenthesizedExpr, + ParenthesizedExpression, + ParseError, + ParseErrorLevel, + ParseLocation, + ParseSourceFile, + ParseSourceSpan, + ParseSpan, + ParseTreeResult, + ParsedEvent, + ParsedEventType, + ParsedProperty, + ParsedPropertyType, + ParsedVariable, + Parser, + PrefixNot, + PropertyRead, + Identifiers as R3Identifiers, + R3NgModuleMetadataKind, + R3SelectorScopeMode, + R3TargetBinder, + R3TemplateDependencyKind, + ReadKeyExpr, + ReadPropExpr, + ReadVarExpr, + RecursiveAstVisitor, + RecursiveVisitor, + ResourceLoader, + ReturnStatement, + SECURITY_SCHEMA, + STRING_TYPE, + SafeCall, + SafeKeyedRead, + SafePropertyRead, + SelectorContext, + SelectorListContext, + SelectorMatcher, + SelectorlessMatcher, + Serializer, + SplitInterpolation, + Statement, + StmtModifier, + StringToken, + StringTokenKind, + TagContentType, + TaggedTemplateLiteral, + TaggedTemplateLiteralExpr, + TemplateBindingParseResult, + TemplateLiteral, + TemplateLiteralElement, + TemplateLiteralElementExpr, + TemplateLiteralExpr, + Text, + ThisReceiver, + BlockNode as TmplAstBlockNode, + BoundAttribute as TmplAstBoundAttribute, + BoundDeferredTrigger as TmplAstBoundDeferredTrigger, + BoundEvent as TmplAstBoundEvent, + BoundText as TmplAstBoundText, + Component$1 as TmplAstComponent, + Content as TmplAstContent, + DeferredBlock as TmplAstDeferredBlock, + DeferredBlockError as TmplAstDeferredBlockError, + DeferredBlockLoading as TmplAstDeferredBlockLoading, + DeferredBlockPlaceholder as TmplAstDeferredBlockPlaceholder, + DeferredTrigger as TmplAstDeferredTrigger, + Directive$1 as TmplAstDirective, + Element$1 as TmplAstElement, + ForLoopBlock as TmplAstForLoopBlock, + ForLoopBlockEmpty as TmplAstForLoopBlockEmpty, + HostElement as TmplAstHostElement, + HoverDeferredTrigger as TmplAstHoverDeferredTrigger, + Icu$1 as TmplAstIcu, + IdleDeferredTrigger as TmplAstIdleDeferredTrigger, + IfBlock as TmplAstIfBlock, + IfBlockBranch as TmplAstIfBlockBranch, + ImmediateDeferredTrigger as TmplAstImmediateDeferredTrigger, + InteractionDeferredTrigger as TmplAstInteractionDeferredTrigger, + LetDeclaration$1 as TmplAstLetDeclaration, + NeverDeferredTrigger as TmplAstNeverDeferredTrigger, + RecursiveVisitor$1 as TmplAstRecursiveVisitor, + Reference as TmplAstReference, + SwitchBlock as TmplAstSwitchBlock, + SwitchBlockCase as TmplAstSwitchBlockCase, + Template as TmplAstTemplate, + Text$3 as TmplAstText, + TextAttribute as TmplAstTextAttribute, + TimerDeferredTrigger as TmplAstTimerDeferredTrigger, + UnknownBlock as TmplAstUnknownBlock, + Variable as TmplAstVariable, + ViewportDeferredTrigger as TmplAstViewportDeferredTrigger, + Token, + TokenType, + TransplantedType, + TreeError, + Type, + TypeModifier, + TypeofExpr, + TypeofExpression, + Unary, + UnaryOperator, + UnaryOperatorExpr, + VERSION, + VariableBinding, + Version, + ViewEncapsulation$1 as ViewEncapsulation, + VoidExpr, + VoidExpression, + WrappedNodeExpr, + Xliff, + Xliff2, + Xmb, + XmlParser, + Xtb, + compileClassDebugInfo, + compileClassMetadata, + compileComponentClassMetadata, + compileComponentDeclareClassMetadata, + compileComponentFromMetadata, + compileDeclareClassMetadata, + compileDeclareComponentFromMetadata, + compileDeclareDirectiveFromMetadata, + compileDeclareFactoryFunction, + compileDeclareInjectableFromMetadata, + compileDeclareInjectorFromMetadata, + compileDeclareNgModuleFromMetadata, + compileDeclarePipeFromMetadata, + compileDeferResolverFunction, + compileDirectiveFromMetadata, + compileFactoryFunction, + compileHmrInitializer, + compileHmrUpdateCallback, + compileInjectable, + compileInjector, + compileNgModule, + compileOpaqueAsyncClassMetadata, + compilePipeFromMetadata, + computeMsgId, + core, + createCssSelectorFromNode, + createInjectableType, + createMayBeForwardRefExpression, + devOnlyGuardedExpression, + emitDistinctChangesOnlyDefaultValue, + encapsulateStyle, + escapeRegExp, + findMatchingDirectivesAndPipes, + getHtmlTagDefinition, + getNsPrefix, + getSafePropertyAccessString, + identifierName, + isNgContainer, + isNgContent, + isNgTemplate, + jsDocComment, + leadingComment, + literal, + literalMap, + makeBindingParser, + mergeNsAndName, + output_ast as outputAst, + parseHostBindings, + parseTemplate, + preserveWhitespacesDefault, + publishFacade, + r3JitTypeSourceSpan, + sanitizeIdentifier, + setEnableTemplateSourceLocations, + splitNsName, + visitAll$1 as tmplAstVisitAll, + verifyHostBindings, + visitAll +}; diff --git a/.angular/cache/20.1.6/TFTPaths/vite/deps/@angular_compiler.js.map b/.angular/cache/20.1.6/TFTPaths/vite/deps/@angular_compiler.js.map new file mode 100644 index 0000000..9865211 --- /dev/null +++ b/.angular/cache/20.1.6/TFTPaths/vite/deps/@angular_compiler.js.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": [], + "sourcesContent": [], + "mappings": "", + "names": [] +} diff --git a/.angular/cache/20.1.6/TFTPaths/vite/deps/@angular_core.js b/.angular/cache/20.1.6/TFTPaths/vite/deps/@angular_core.js new file mode 100644 index 0000000..b0539ce --- /dev/null +++ b/.angular/cache/20.1.6/TFTPaths/vite/deps/@angular_core.js @@ -0,0 +1,981 @@ +import { + ALLOW_MULTIPLE_PLATFORMS, + ANIMATION_MODULE_TYPE, + APP_BOOTSTRAP_LISTENER, + APP_ID, + APP_INITIALIZER, + AcxChangeDetectionStrategy, + AcxViewEncapsulation, + AfterRenderManager, + ApplicationInitStatus, + ApplicationModule, + ApplicationRef, + Attribute, + CLIENT_RENDER_MODE_FLAG, + COMPILER_OPTIONS, + CONTAINER_HEADER_OFFSET, + CSP_NONCE, + CUSTOM_ELEMENTS_SCHEMA, + ChangeDetectionScheduler, + ChangeDetectionSchedulerImpl, + ChangeDetectionStrategy, + ChangeDetectorRef, + Compiler, + CompilerFactory, + Component, + ComponentFactory, + ComponentFactory$1, + ComponentFactoryResolver$1, + ComponentRef, + ComponentRef$1, + Console, + ContentChild, + ContentChildren, + DEFAULT_CURRENCY_CODE, + DEFAULT_LOCALE_ID, + DEFER_BLOCK_CONFIG, + DEFER_BLOCK_DEPENDENCY_INTERCEPTOR, + DEHYDRATED_BLOCK_REGISTRY, + DOCUMENT, + DebugElement, + DebugEventListener, + DebugNode, + DefaultIterableDiffer, + DeferBlockBehavior, + DeferBlockState, + DestroyRef, + Directive, + ENABLE_ROOT_COMPONENT_BOOTSTRAP, + ENVIRONMENT_INITIALIZER, + EffectScheduler, + ElementRef, + EmbeddedViewRef, + EnvironmentInjector, + ErrorHandler, + EventEmitter, + FactoryTarget, + Framework, + HOST_TAG_NAME, + Host, + HostAttributeToken, + HostBinding, + HostListener, + HydrationStatus, + IMAGE_CONFIG, + IMAGE_CONFIG_DEFAULTS, + INJECTOR$1, + INJECTOR_SCOPE, + INTERNAL_APPLICATION_ERROR_HANDLER, + IS_HYDRATION_DOM_REUSE_ENABLED, + IS_INCREMENTAL_HYDRATION_ENABLED, + Inject, + Injectable, + InjectionToken, + Injector, + Input, + IterableDiffers, + JSACTION_BLOCK_ELEMENT_MAP, + JSACTION_EVENT_CONTRACT, + KeyValueDiffers, + LContext, + LOCALE_ID, + LocaleDataIndex, + MissingTranslationStrategy, + ModuleWithComponentFactories, + NG_COMP_DEF, + NG_DIR_DEF, + NG_ELEMENT_ID, + NG_INJ_DEF, + NG_MOD_DEF, + NG_PIPE_DEF, + NG_PROV_DEF, + NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, + NO_CHANGE, + NO_ERRORS_SCHEMA, + NgModule, + NgModuleFactory, + NgModuleFactory$1, + NgModuleRef, + NgModuleRef$1, + NgProbeToken, + NgZone, + NoopNgZone, + Optional, + Output, + OutputEmitterRef, + PACKAGE_ROOT_URL, + PERFORMANCE_MARK_PREFIX, + PLATFORM_ID, + PLATFORM_INITIALIZER, + PROVIDED_NG_ZONE, + PendingTasks, + PendingTasksInternal, + Pipe, + PlatformRef, + Query, + QueryList, + R3Injector, + REQUEST, + REQUEST_CONTEXT, + RESPONSE_INIT, + ReflectionCapabilities, + Renderer2, + RendererFactory2, + RendererStyleFlags2, + ResourceImpl, + RuntimeError, + SIGNAL, + SSR_CONTENT_INTEGRITY_MARKER, + Sanitizer, + SecurityContext, + Self, + SimpleChange, + SkipSelf, + TESTABILITY, + TESTABILITY_GETTER, + TRANSLATIONS, + TRANSLATIONS_FORMAT, + TemplateRef, + Testability, + TestabilityRegistry, + TimerScheduler, + TracingAction, + TracingService, + TransferState, + Type, + VERSION, + Version, + ViewChild, + ViewChildren, + ViewContainerRef, + ViewEncapsulation, + ViewRef, + ViewRef2, + XSS_SECURITY_URL, + ZONELESS_ENABLED, + _global, + _sanitizeHtml, + _sanitizeUrl, + afterEveryRender, + afterNextRender, + afterRenderEffect, + allowSanitizationBypassAndThrow, + annotateForHydration, + asNativeElements, + assertInInjectionContext, + assertNotInReactiveContext, + assertPlatform, + booleanAttribute, + bypassSanitizationTrustHtml, + bypassSanitizationTrustResourceUrl, + bypassSanitizationTrustScript, + bypassSanitizationTrustStyle, + bypassSanitizationTrustUrl, + clearResolutionOfComponentResourcesQueue, + compileComponent, + compileDirective, + compileNgModule, + compileNgModuleDefs, + compileNgModuleFactory, + compilePipe, + computed, + contentChild, + contentChildren, + convertToBitFlags, + createComponent, + createEnvironmentInjector, + createInjector, + createNgModule, + createNgModuleRef, + createOrReusePlatformInjector, + createPlatform, + createPlatformFactory, + defaultIterableDiffers, + defaultKeyValueDiffers, + defineInjectable, + depsTracker, + destroyPlatform, + devModeEqual, + disableProfiling, + effect, + enableProdMode, + enableProfiling, + enableProfiling2, + encapsulateResourceError, + findLocaleData, + flushModuleScopingQueueAsMuchAsPossible, + formatRuntimeError, + forwardRef, + generateStandaloneInDeclarationsError, + getAsyncClassMetadataFn, + getClosestComponentName, + getComponentDef, + getDebugNode, + getDeferBlocks$1, + getDirectives, + getDocument, + getHostElement, + getInjectableDef, + getLContext, + getLocaleCurrencyCode, + getLocalePluralCase, + getModuleFactory, + getNgModuleById, + getOutputDestroyRef, + getPlatform, + getSanitizationBypassType, + getTransferState, + importProvidersFrom, + inject, + injectChangeDetectorRef, + input, + inputBinding, + internalCreateApplication, + internalProvideZoneChangeDetection, + isBoundToModule, + isComponentDefPendingResolution, + isDevMode, + isEnvironmentProviders, + isInjectable, + isNgModule, + isPromise, + isSignal, + isStandalone, + isSubscribable, + isViewDirty, + linkedSignal, + makeEnvironmentProviders, + makeStateKey, + markForRefresh, + mergeApplicationConfig, + model, + noSideEffects, + numberAttribute, + output, + outputBinding, + patchComponentDefWithScope, + performanceMarkFeature, + platformCore, + provideAppInitializer, + provideBrowserGlobalErrorListeners, + provideCheckNoChangesConfig, + provideEnvironmentInitializer, + provideNgReflectAttributes, + providePlatformInitializer, + provideZoneChangeDetection, + provideZonelessChangeDetection, + publishExternalGlobalUtil, + readHydrationInfo, + reflectComponentType, + registerLocaleData, + registerNgModuleType, + renderDeferBlockState, + resetCompiledComponents, + resetJitOptions, + resolveComponentResources, + resolveForwardRef, + resource, + restoreComponentResolutionQueue, + runInInjectionContext, + setAllowDuplicateNgModuleIdsForTest, + setAlternateWeakRefImpl, + setClassMetadata, + setClassMetadataAsync, + setCurrentInjector, + setDocument, + setInjectorProfilerContext, + setLocaleId, + setTestabilityGetter, + signal, + startMeasuring, + stopMeasuring, + store, + stringify, + transitiveScopesFor, + triggerResourceLoading, + truncateMiddle, + twoWayBinding, + unregisterAllLocaleData, + untracked, + unwrapSafeValue, + viewChild, + viewChildren, + withDomHydration, + withEventReplay, + withI18nSupport, + withIncrementalHydration, + ɵINPUT_SIGNAL_BRAND_WRITE_TYPE, + ɵassertType, + ɵgetUnknownElementStrictMode, + ɵgetUnknownPropertyStrictMode, + ɵsetClassDebugInfo, + ɵsetUnknownElementStrictMode, + ɵsetUnknownPropertyStrictMode, + ɵunwrapWritableSignal, + ɵɵCopyDefinitionFeature, + ɵɵExternalStylesFeature, + ɵɵHostDirectivesFeature, + ɵɵInheritDefinitionFeature, + ɵɵNgOnChangesFeature, + ɵɵProvidersFeature, + ɵɵadvance, + ɵɵattachSourceLocations, + ɵɵattribute, + ɵɵclassMap, + ɵɵclassProp, + ɵɵcomponentInstance, + ɵɵconditional, + ɵɵconditionalBranchCreate, + ɵɵconditionalCreate, + ɵɵcontentQuery, + ɵɵcontentQuerySignal, + ɵɵdeclareLet, + ɵɵdefer, + ɵɵdeferEnableTimerScheduling, + ɵɵdeferHydrateNever, + ɵɵdeferHydrateOnHover, + ɵɵdeferHydrateOnIdle, + ɵɵdeferHydrateOnImmediate, + ɵɵdeferHydrateOnInteraction, + ɵɵdeferHydrateOnTimer, + ɵɵdeferHydrateOnViewport, + ɵɵdeferHydrateWhen, + ɵɵdeferOnHover, + ɵɵdeferOnIdle, + ɵɵdeferOnImmediate, + ɵɵdeferOnInteraction, + ɵɵdeferOnTimer, + ɵɵdeferOnViewport, + ɵɵdeferPrefetchOnHover, + ɵɵdeferPrefetchOnIdle, + ɵɵdeferPrefetchOnImmediate, + ɵɵdeferPrefetchOnInteraction, + ɵɵdeferPrefetchOnTimer, + ɵɵdeferPrefetchOnViewport, + ɵɵdeferPrefetchWhen, + ɵɵdeferWhen, + ɵɵdefineComponent, + ɵɵdefineDirective, + ɵɵdefineInjectable, + ɵɵdefineInjector, + ɵɵdefineNgModule, + ɵɵdefinePipe, + ɵɵdirectiveInject, + ɵɵdisableBindings, + ɵɵdomElement, + ɵɵdomElementContainer, + ɵɵdomElementContainerEnd, + ɵɵdomElementContainerStart, + ɵɵdomElementEnd, + ɵɵdomElementStart, + ɵɵdomListener, + ɵɵdomProperty, + ɵɵdomTemplate, + ɵɵelement, + ɵɵelementContainer, + ɵɵelementContainerEnd, + ɵɵelementContainerStart, + ɵɵelementEnd, + ɵɵelementStart, + ɵɵenableBindings, + ɵɵgetComponentDepsFactory, + ɵɵgetCurrentView, + ɵɵgetInheritedFactory, + ɵɵgetReplaceMetadataURL, + ɵɵi18n, + ɵɵi18nApply, + ɵɵi18nAttributes, + ɵɵi18nEnd, + ɵɵi18nExp, + ɵɵi18nPostprocess, + ɵɵi18nStart, + ɵɵinject, + ɵɵinjectAttribute, + ɵɵinterpolate, + ɵɵinterpolate1, + ɵɵinterpolate2, + ɵɵinterpolate3, + ɵɵinterpolate4, + ɵɵinterpolate5, + ɵɵinterpolate6, + ɵɵinterpolate7, + ɵɵinterpolate8, + ɵɵinterpolateV, + ɵɵinvalidFactory, + ɵɵinvalidFactoryDep, + ɵɵlistener, + ɵɵloadQuery, + ɵɵnamespaceHTML, + ɵɵnamespaceMathML, + ɵɵnamespaceSVG, + ɵɵnextContext, + ɵɵngDeclareClassMetadata, + ɵɵngDeclareClassMetadataAsync, + ɵɵngDeclareComponent, + ɵɵngDeclareDirective, + ɵɵngDeclareFactory, + ɵɵngDeclareInjectable, + ɵɵngDeclareInjector, + ɵɵngDeclareNgModule, + ɵɵngDeclarePipe, + ɵɵpipe, + ɵɵpipeBind1, + ɵɵpipeBind2, + ɵɵpipeBind3, + ɵɵpipeBind4, + ɵɵpipeBindV, + ɵɵprojection, + ɵɵprojectionDef, + ɵɵproperty, + ɵɵpureFunction0, + ɵɵpureFunction1, + ɵɵpureFunction2, + ɵɵpureFunction3, + ɵɵpureFunction4, + ɵɵpureFunction5, + ɵɵpureFunction6, + ɵɵpureFunction7, + ɵɵpureFunction8, + ɵɵpureFunctionV, + ɵɵqueryAdvance, + ɵɵqueryRefresh, + ɵɵreadContextLet, + ɵɵreference, + ɵɵrepeater, + ɵɵrepeaterCreate, + ɵɵrepeaterTrackByIdentity, + ɵɵrepeaterTrackByIndex, + ɵɵreplaceMetadata, + ɵɵresetView, + ɵɵresolveBody, + ɵɵresolveDocument, + ɵɵresolveWindow, + ɵɵrestoreView, + ɵɵsanitizeHtml, + ɵɵsanitizeResourceUrl, + ɵɵsanitizeScript, + ɵɵsanitizeStyle, + ɵɵsanitizeUrl, + ɵɵsanitizeUrlOrResourceUrl, + ɵɵsetComponentScope, + ɵɵsetNgModuleScope, + ɵɵstoreLet, + ɵɵstyleMap, + ɵɵstyleProp, + ɵɵsyntheticHostListener, + ɵɵsyntheticHostProperty, + ɵɵtemplate, + ɵɵtemplateRefExtractor, + ɵɵtext, + ɵɵtextInterpolate, + ɵɵtextInterpolate1, + ɵɵtextInterpolate2, + ɵɵtextInterpolate3, + ɵɵtextInterpolate4, + ɵɵtextInterpolate5, + ɵɵtextInterpolate6, + ɵɵtextInterpolate7, + ɵɵtextInterpolate8, + ɵɵtextInterpolateV, + ɵɵtrustConstantHtml, + ɵɵtrustConstantResourceUrl, + ɵɵtwoWayBindingSet, + ɵɵtwoWayListener, + ɵɵtwoWayProperty, + ɵɵvalidateIframeAttribute, + ɵɵviewQuery, + ɵɵviewQuerySignal +} from "./chunk-T7UM462Y.js"; +import "./chunk-6OOPNYDU.js"; +import "./chunk-7PMVITZM.js"; +import "./chunk-3OV72XIM.js"; +export { + ANIMATION_MODULE_TYPE, + APP_BOOTSTRAP_LISTENER, + APP_ID, + APP_INITIALIZER, + ApplicationInitStatus, + ApplicationModule, + ApplicationRef, + Attribute, + COMPILER_OPTIONS, + CSP_NONCE, + CUSTOM_ELEMENTS_SCHEMA, + ChangeDetectionStrategy, + ChangeDetectorRef, + Compiler, + CompilerFactory, + Component, + ComponentFactory$1 as ComponentFactory, + ComponentFactoryResolver$1 as ComponentFactoryResolver, + ComponentRef$1 as ComponentRef, + ContentChild, + ContentChildren, + DEFAULT_CURRENCY_CODE, + DOCUMENT, + DebugElement, + DebugEventListener, + DebugNode, + DefaultIterableDiffer, + DestroyRef, + Directive, + ENVIRONMENT_INITIALIZER, + ElementRef, + EmbeddedViewRef, + EnvironmentInjector, + ErrorHandler, + EventEmitter, + HOST_TAG_NAME, + Host, + HostAttributeToken, + HostBinding, + HostListener, + INJECTOR$1 as INJECTOR, + Inject, + Injectable, + InjectionToken, + Injector, + Input, + IterableDiffers, + KeyValueDiffers, + LOCALE_ID, + MissingTranslationStrategy, + ModuleWithComponentFactories, + NO_ERRORS_SCHEMA, + NgModule, + NgModuleFactory$1 as NgModuleFactory, + NgModuleRef$1 as NgModuleRef, + NgProbeToken, + NgZone, + Optional, + Output, + OutputEmitterRef, + PACKAGE_ROOT_URL, + PLATFORM_ID, + PLATFORM_INITIALIZER, + PendingTasks, + Pipe, + PlatformRef, + Query, + QueryList, + REQUEST, + REQUEST_CONTEXT, + RESPONSE_INIT, + Renderer2, + RendererFactory2, + RendererStyleFlags2, + Sanitizer, + SecurityContext, + Self, + SimpleChange, + SkipSelf, + TRANSLATIONS, + TRANSLATIONS_FORMAT, + TemplateRef, + Testability, + TestabilityRegistry, + TransferState, + Type, + VERSION, + Version, + ViewChild, + ViewChildren, + ViewContainerRef, + ViewEncapsulation, + ViewRef2 as ViewRef, + afterEveryRender, + afterNextRender, + afterRenderEffect, + asNativeElements, + assertInInjectionContext, + assertNotInReactiveContext, + assertPlatform, + booleanAttribute, + computed, + contentChild, + contentChildren, + createComponent, + createEnvironmentInjector, + createNgModule, + createNgModuleRef, + createPlatform, + createPlatformFactory, + defineInjectable, + destroyPlatform, + effect, + enableProdMode, + enableProfiling, + forwardRef, + getDebugNode, + getModuleFactory, + getNgModuleById, + getPlatform, + importProvidersFrom, + inject, + input, + inputBinding, + isDevMode, + isSignal, + isStandalone, + linkedSignal, + makeEnvironmentProviders, + makeStateKey, + mergeApplicationConfig, + model, + numberAttribute, + output, + outputBinding, + platformCore, + provideAppInitializer, + provideBrowserGlobalErrorListeners, + provideCheckNoChangesConfig, + provideEnvironmentInitializer, + provideNgReflectAttributes, + providePlatformInitializer, + provideZoneChangeDetection, + provideZonelessChangeDetection, + reflectComponentType, + resolveForwardRef, + resource, + runInInjectionContext, + setTestabilityGetter, + signal, + twoWayBinding, + untracked, + viewChild, + viewChildren, + ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS, + AcxChangeDetectionStrategy as ɵAcxChangeDetectionStrategy, + AcxViewEncapsulation as ɵAcxViewEncapsulation, + AfterRenderManager as ɵAfterRenderManager, + CLIENT_RENDER_MODE_FLAG as ɵCLIENT_RENDER_MODE_FLAG, + CONTAINER_HEADER_OFFSET as ɵCONTAINER_HEADER_OFFSET, + ChangeDetectionScheduler as ɵChangeDetectionScheduler, + ChangeDetectionSchedulerImpl as ɵChangeDetectionSchedulerImpl, + ComponentFactory$1 as ɵComponentFactory, + Console as ɵConsole, + DEFAULT_LOCALE_ID as ɵDEFAULT_LOCALE_ID, + DEFER_BLOCK_CONFIG as ɵDEFER_BLOCK_CONFIG, + DEFER_BLOCK_DEPENDENCY_INTERCEPTOR as ɵDEFER_BLOCK_DEPENDENCY_INTERCEPTOR, + DEHYDRATED_BLOCK_REGISTRY as ɵDEHYDRATED_BLOCK_REGISTRY, + DeferBlockBehavior as ɵDeferBlockBehavior, + DeferBlockState as ɵDeferBlockState, + ENABLE_ROOT_COMPONENT_BOOTSTRAP as ɵENABLE_ROOT_COMPONENT_BOOTSTRAP, + EffectScheduler as ɵEffectScheduler, + Framework as ɵFramework, + HydrationStatus as ɵHydrationStatus, + IMAGE_CONFIG as ɵIMAGE_CONFIG, + IMAGE_CONFIG_DEFAULTS as ɵIMAGE_CONFIG_DEFAULTS, + INJECTOR_SCOPE as ɵINJECTOR_SCOPE, + ɵINPUT_SIGNAL_BRAND_WRITE_TYPE, + INTERNAL_APPLICATION_ERROR_HANDLER as ɵINTERNAL_APPLICATION_ERROR_HANDLER, + IS_HYDRATION_DOM_REUSE_ENABLED as ɵIS_HYDRATION_DOM_REUSE_ENABLED, + IS_INCREMENTAL_HYDRATION_ENABLED as ɵIS_INCREMENTAL_HYDRATION_ENABLED, + JSACTION_BLOCK_ELEMENT_MAP as ɵJSACTION_BLOCK_ELEMENT_MAP, + JSACTION_EVENT_CONTRACT as ɵJSACTION_EVENT_CONTRACT, + LContext as ɵLContext, + LocaleDataIndex as ɵLocaleDataIndex, + NG_COMP_DEF as ɵNG_COMP_DEF, + NG_DIR_DEF as ɵNG_DIR_DEF, + NG_ELEMENT_ID as ɵNG_ELEMENT_ID, + NG_INJ_DEF as ɵNG_INJ_DEF, + NG_MOD_DEF as ɵNG_MOD_DEF, + NG_PIPE_DEF as ɵNG_PIPE_DEF, + NG_PROV_DEF as ɵNG_PROV_DEF, + NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, + NO_CHANGE as ɵNO_CHANGE, + NgModuleFactory as ɵNgModuleFactory, + NoopNgZone as ɵNoopNgZone, + PERFORMANCE_MARK_PREFIX as ɵPERFORMANCE_MARK_PREFIX, + PROVIDED_NG_ZONE as ɵPROVIDED_NG_ZONE, + PendingTasksInternal as ɵPendingTasksInternal, + R3Injector as ɵR3Injector, + ReflectionCapabilities as ɵReflectionCapabilities, + ComponentFactory as ɵRender3ComponentFactory, + ComponentRef as ɵRender3ComponentRef, + NgModuleRef as ɵRender3NgModuleRef, + ResourceImpl as ɵResourceImpl, + RuntimeError as ɵRuntimeError, + SIGNAL as ɵSIGNAL, + SSR_CONTENT_INTEGRITY_MARKER as ɵSSR_CONTENT_INTEGRITY_MARKER, + TESTABILITY as ɵTESTABILITY, + TESTABILITY_GETTER as ɵTESTABILITY_GETTER, + TimerScheduler as ɵTimerScheduler, + TracingAction as ɵTracingAction, + TracingService as ɵTracingService, + ViewRef as ɵViewRef, + XSS_SECURITY_URL as ɵXSS_SECURITY_URL, + ZONELESS_ENABLED as ɵZONELESS_ENABLED, + _sanitizeHtml as ɵ_sanitizeHtml, + _sanitizeUrl as ɵ_sanitizeUrl, + allowSanitizationBypassAndThrow as ɵallowSanitizationBypassAndThrow, + annotateForHydration as ɵannotateForHydration, + ɵassertType, + bypassSanitizationTrustHtml as ɵbypassSanitizationTrustHtml, + bypassSanitizationTrustResourceUrl as ɵbypassSanitizationTrustResourceUrl, + bypassSanitizationTrustScript as ɵbypassSanitizationTrustScript, + bypassSanitizationTrustStyle as ɵbypassSanitizationTrustStyle, + bypassSanitizationTrustUrl as ɵbypassSanitizationTrustUrl, + clearResolutionOfComponentResourcesQueue as ɵclearResolutionOfComponentResourcesQueue, + compileComponent as ɵcompileComponent, + compileDirective as ɵcompileDirective, + compileNgModule as ɵcompileNgModule, + compileNgModuleDefs as ɵcompileNgModuleDefs, + compileNgModuleFactory as ɵcompileNgModuleFactory, + compilePipe as ɵcompilePipe, + convertToBitFlags as ɵconvertToBitFlags, + createInjector as ɵcreateInjector, + createOrReusePlatformInjector as ɵcreateOrReusePlatformInjector, + defaultIterableDiffers as ɵdefaultIterableDiffers, + defaultKeyValueDiffers as ɵdefaultKeyValueDiffers, + depsTracker as ɵdepsTracker, + devModeEqual as ɵdevModeEqual, + disableProfiling as ɵdisableProfiling, + enableProfiling2 as ɵenableProfiling, + encapsulateResourceError as ɵencapsulateResourceError, + findLocaleData as ɵfindLocaleData, + flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, + formatRuntimeError as ɵformatRuntimeError, + generateStandaloneInDeclarationsError as ɵgenerateStandaloneInDeclarationsError, + getAsyncClassMetadataFn as ɵgetAsyncClassMetadataFn, + getClosestComponentName as ɵgetClosestComponentName, + getComponentDef as ɵgetComponentDef, + getDebugNode as ɵgetDebugNode, + getDeferBlocks$1 as ɵgetDeferBlocks, + getDirectives as ɵgetDirectives, + getDocument as ɵgetDocument, + getHostElement as ɵgetHostElement, + getInjectableDef as ɵgetInjectableDef, + getLContext as ɵgetLContext, + getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, + getLocalePluralCase as ɵgetLocalePluralCase, + getOutputDestroyRef as ɵgetOutputDestroyRef, + getSanitizationBypassType as ɵgetSanitizationBypassType, + getTransferState as ɵgetTransferState, + ɵgetUnknownElementStrictMode, + ɵgetUnknownPropertyStrictMode, + _global as ɵglobal, + injectChangeDetectorRef as ɵinjectChangeDetectorRef, + internalCreateApplication as ɵinternalCreateApplication, + internalProvideZoneChangeDetection as ɵinternalProvideZoneChangeDetection, + isBoundToModule as ɵisBoundToModule, + isComponentDefPendingResolution as ɵisComponentDefPendingResolution, + isEnvironmentProviders as ɵisEnvironmentProviders, + isInjectable as ɵisInjectable, + isNgModule as ɵisNgModule, + isPromise as ɵisPromise, + isSubscribable as ɵisSubscribable, + isViewDirty as ɵisViewDirty, + markForRefresh as ɵmarkForRefresh, + noSideEffects as ɵnoSideEffects, + patchComponentDefWithScope as ɵpatchComponentDefWithScope, + performanceMarkFeature as ɵperformanceMarkFeature, + publishExternalGlobalUtil as ɵpublishExternalGlobalUtil, + readHydrationInfo as ɵreadHydrationInfo, + registerLocaleData as ɵregisterLocaleData, + renderDeferBlockState as ɵrenderDeferBlockState, + resetCompiledComponents as ɵresetCompiledComponents, + resetJitOptions as ɵresetJitOptions, + resolveComponentResources as ɵresolveComponentResources, + restoreComponentResolutionQueue as ɵrestoreComponentResolutionQueue, + setAllowDuplicateNgModuleIdsForTest as ɵsetAllowDuplicateNgModuleIdsForTest, + setAlternateWeakRefImpl as ɵsetAlternateWeakRefImpl, + ɵsetClassDebugInfo, + setClassMetadata as ɵsetClassMetadata, + setClassMetadataAsync as ɵsetClassMetadataAsync, + setCurrentInjector as ɵsetCurrentInjector, + setDocument as ɵsetDocument, + setInjectorProfilerContext as ɵsetInjectorProfilerContext, + setLocaleId as ɵsetLocaleId, + ɵsetUnknownElementStrictMode, + ɵsetUnknownPropertyStrictMode, + startMeasuring as ɵstartMeasuring, + stopMeasuring as ɵstopMeasuring, + store as ɵstore, + stringify as ɵstringify, + transitiveScopesFor as ɵtransitiveScopesFor, + triggerResourceLoading as ɵtriggerResourceLoading, + truncateMiddle as ɵtruncateMiddle, + unregisterAllLocaleData as ɵunregisterLocaleData, + unwrapSafeValue as ɵunwrapSafeValue, + ɵunwrapWritableSignal, + withDomHydration as ɵwithDomHydration, + withEventReplay as ɵwithEventReplay, + withI18nSupport as ɵwithI18nSupport, + withIncrementalHydration as ɵwithIncrementalHydration, + ɵɵCopyDefinitionFeature, + ɵɵExternalStylesFeature, + FactoryTarget as ɵɵFactoryTarget, + ɵɵHostDirectivesFeature, + ɵɵInheritDefinitionFeature, + ɵɵNgOnChangesFeature, + ɵɵProvidersFeature, + ɵɵadvance, + ɵɵattachSourceLocations, + ɵɵattribute, + ɵɵclassMap, + ɵɵclassProp, + ɵɵcomponentInstance, + ɵɵconditional, + ɵɵconditionalBranchCreate, + ɵɵconditionalCreate, + ɵɵcontentQuery, + ɵɵcontentQuerySignal, + ɵɵdeclareLet, + ɵɵdefer, + ɵɵdeferEnableTimerScheduling, + ɵɵdeferHydrateNever, + ɵɵdeferHydrateOnHover, + ɵɵdeferHydrateOnIdle, + ɵɵdeferHydrateOnImmediate, + ɵɵdeferHydrateOnInteraction, + ɵɵdeferHydrateOnTimer, + ɵɵdeferHydrateOnViewport, + ɵɵdeferHydrateWhen, + ɵɵdeferOnHover, + ɵɵdeferOnIdle, + ɵɵdeferOnImmediate, + ɵɵdeferOnInteraction, + ɵɵdeferOnTimer, + ɵɵdeferOnViewport, + ɵɵdeferPrefetchOnHover, + ɵɵdeferPrefetchOnIdle, + ɵɵdeferPrefetchOnImmediate, + ɵɵdeferPrefetchOnInteraction, + ɵɵdeferPrefetchOnTimer, + ɵɵdeferPrefetchOnViewport, + ɵɵdeferPrefetchWhen, + ɵɵdeferWhen, + ɵɵdefineComponent, + ɵɵdefineDirective, + ɵɵdefineInjectable, + ɵɵdefineInjector, + ɵɵdefineNgModule, + ɵɵdefinePipe, + ɵɵdirectiveInject, + ɵɵdisableBindings, + ɵɵdomElement, + ɵɵdomElementContainer, + ɵɵdomElementContainerEnd, + ɵɵdomElementContainerStart, + ɵɵdomElementEnd, + ɵɵdomElementStart, + ɵɵdomListener, + ɵɵdomProperty, + ɵɵdomTemplate, + ɵɵelement, + ɵɵelementContainer, + ɵɵelementContainerEnd, + ɵɵelementContainerStart, + ɵɵelementEnd, + ɵɵelementStart, + ɵɵenableBindings, + ɵɵgetComponentDepsFactory, + ɵɵgetCurrentView, + ɵɵgetInheritedFactory, + ɵɵgetReplaceMetadataURL, + ɵɵi18n, + ɵɵi18nApply, + ɵɵi18nAttributes, + ɵɵi18nEnd, + ɵɵi18nExp, + ɵɵi18nPostprocess, + ɵɵi18nStart, + ɵɵinject, + ɵɵinjectAttribute, + ɵɵinterpolate, + ɵɵinterpolate1, + ɵɵinterpolate2, + ɵɵinterpolate3, + ɵɵinterpolate4, + ɵɵinterpolate5, + ɵɵinterpolate6, + ɵɵinterpolate7, + ɵɵinterpolate8, + ɵɵinterpolateV, + ɵɵinvalidFactory, + ɵɵinvalidFactoryDep, + ɵɵlistener, + ɵɵloadQuery, + ɵɵnamespaceHTML, + ɵɵnamespaceMathML, + ɵɵnamespaceSVG, + ɵɵnextContext, + ɵɵngDeclareClassMetadata, + ɵɵngDeclareClassMetadataAsync, + ɵɵngDeclareComponent, + ɵɵngDeclareDirective, + ɵɵngDeclareFactory, + ɵɵngDeclareInjectable, + ɵɵngDeclareInjector, + ɵɵngDeclareNgModule, + ɵɵngDeclarePipe, + ɵɵpipe, + ɵɵpipeBind1, + ɵɵpipeBind2, + ɵɵpipeBind3, + ɵɵpipeBind4, + ɵɵpipeBindV, + ɵɵprojection, + ɵɵprojectionDef, + ɵɵproperty, + ɵɵpureFunction0, + ɵɵpureFunction1, + ɵɵpureFunction2, + ɵɵpureFunction3, + ɵɵpureFunction4, + ɵɵpureFunction5, + ɵɵpureFunction6, + ɵɵpureFunction7, + ɵɵpureFunction8, + ɵɵpureFunctionV, + ɵɵqueryAdvance, + ɵɵqueryRefresh, + ɵɵreadContextLet, + ɵɵreference, + registerNgModuleType as ɵɵregisterNgModuleType, + ɵɵrepeater, + ɵɵrepeaterCreate, + ɵɵrepeaterTrackByIdentity, + ɵɵrepeaterTrackByIndex, + ɵɵreplaceMetadata, + ɵɵresetView, + ɵɵresolveBody, + ɵɵresolveDocument, + ɵɵresolveWindow, + ɵɵrestoreView, + ɵɵsanitizeHtml, + ɵɵsanitizeResourceUrl, + ɵɵsanitizeScript, + ɵɵsanitizeStyle, + ɵɵsanitizeUrl, + ɵɵsanitizeUrlOrResourceUrl, + ɵɵsetComponentScope, + ɵɵsetNgModuleScope, + ɵɵstoreLet, + ɵɵstyleMap, + ɵɵstyleProp, + ɵɵsyntheticHostListener, + ɵɵsyntheticHostProperty, + ɵɵtemplate, + ɵɵtemplateRefExtractor, + ɵɵtext, + ɵɵtextInterpolate, + ɵɵtextInterpolate1, + ɵɵtextInterpolate2, + ɵɵtextInterpolate3, + ɵɵtextInterpolate4, + ɵɵtextInterpolate5, + ɵɵtextInterpolate6, + ɵɵtextInterpolate7, + ɵɵtextInterpolate8, + ɵɵtextInterpolateV, + ɵɵtrustConstantHtml, + ɵɵtrustConstantResourceUrl, + ɵɵtwoWayBindingSet, + ɵɵtwoWayListener, + ɵɵtwoWayProperty, + ɵɵvalidateIframeAttribute, + ɵɵviewQuery, + ɵɵviewQuerySignal +}; diff --git a/.angular/cache/20.1.6/TFTPaths/vite/deps/@angular_core.js.map b/.angular/cache/20.1.6/TFTPaths/vite/deps/@angular_core.js.map new file mode 100644 index 0000000..9865211 --- /dev/null +++ b/.angular/cache/20.1.6/TFTPaths/vite/deps/@angular_core.js.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": [], + "sourcesContent": [], + "mappings": "", + "names": [] +} diff --git a/.angular/cache/20.1.6/TFTPaths/vite/deps/@angular_forms.js b/.angular/cache/20.1.6/TFTPaths/vite/deps/@angular_forms.js new file mode 100644 index 0000000..87eaf5c --- /dev/null +++ b/.angular/cache/20.1.6/TFTPaths/vite/deps/@angular_forms.js @@ -0,0 +1,6956 @@ +import { + getDOM +} from "./chunk-J7WYVKQ5.js"; +import { + ApplicationRef, + ChangeDetectorRef, + DestroyRef, + Directive, + ElementRef, + EventEmitter, + Host, + Inject, + Injectable, + InjectionToken, + Injector, + Input, + NgModule, + Optional, + Output, + Renderer2, + RuntimeError, + Self, + SkipSelf, + Version, + afterNextRender, + booleanAttribute, + computed, + forwardRef, + inject, + isPromise, + isSubscribable, + setClassMetadata, + signal, + untracked, + ɵɵInheritDefinitionFeature, + ɵɵNgOnChangesFeature, + ɵɵProvidersFeature, + ɵɵattribute, + ɵɵclassProp, + ɵɵdefineDirective, + ɵɵdefineInjectable, + ɵɵdefineInjector, + ɵɵdefineNgModule, + ɵɵdirectiveInject, + ɵɵgetInheritedFactory, + ɵɵlistener +} from "./chunk-T7UM462Y.js"; +import { + Subject, + forkJoin, + from, + map +} from "./chunk-6OOPNYDU.js"; +import "./chunk-7PMVITZM.js"; +import { + __spreadProps, + __spreadValues +} from "./chunk-3OV72XIM.js"; + +// node_modules/@angular/forms/fesm2022/forms.mjs +var BaseControlValueAccessor = class _BaseControlValueAccessor { + _renderer; + _elementRef; + /** + * The registered callback function called when a change or input event occurs on the input + * element. + * @docs-private + */ + onChange = (_) => { + }; + /** + * The registered callback function called when a blur event occurs on the input element. + * @docs-private + */ + onTouched = () => { + }; + constructor(_renderer, _elementRef) { + this._renderer = _renderer; + this._elementRef = _elementRef; + } + /** + * Helper method that sets a property on a target element using the current Renderer + * implementation. + * @docs-private + */ + setProperty(key, value) { + this._renderer.setProperty(this._elementRef.nativeElement, key, value); + } + /** + * Registers a function called when the control is touched. + * @docs-private + */ + registerOnTouched(fn) { + this.onTouched = fn; + } + /** + * Registers a function called when the control value changes. + * @docs-private + */ + registerOnChange(fn) { + this.onChange = fn; + } + /** + * Sets the "disabled" property on the range input element. + * @docs-private + */ + setDisabledState(isDisabled) { + this.setProperty("disabled", isDisabled); + } + static ɵfac = function BaseControlValueAccessor_Factory(__ngFactoryType__) { + return new (__ngFactoryType__ || _BaseControlValueAccessor)(ɵɵdirectiveInject(Renderer2), ɵɵdirectiveInject(ElementRef)); + }; + static ɵdir = ɵɵdefineDirective({ + type: _BaseControlValueAccessor + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(BaseControlValueAccessor, [{ + type: Directive + }], () => [{ + type: Renderer2 + }, { + type: ElementRef + }], null); +})(); +var BuiltInControlValueAccessor = class _BuiltInControlValueAccessor extends BaseControlValueAccessor { + static ɵfac = /* @__PURE__ */ (() => { + let ɵBuiltInControlValueAccessor_BaseFactory; + return function BuiltInControlValueAccessor_Factory(__ngFactoryType__) { + return (ɵBuiltInControlValueAccessor_BaseFactory || (ɵBuiltInControlValueAccessor_BaseFactory = ɵɵgetInheritedFactory(_BuiltInControlValueAccessor)))(__ngFactoryType__ || _BuiltInControlValueAccessor); + }; + })(); + static ɵdir = ɵɵdefineDirective({ + type: _BuiltInControlValueAccessor, + features: [ɵɵInheritDefinitionFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(BuiltInControlValueAccessor, [{ + type: Directive + }], null, null); +})(); +var NG_VALUE_ACCESSOR = new InjectionToken(ngDevMode ? "NgValueAccessor" : ""); +var CHECKBOX_VALUE_ACCESSOR = { + provide: NG_VALUE_ACCESSOR, + useExisting: forwardRef(() => CheckboxControlValueAccessor), + multi: true +}; +var CheckboxControlValueAccessor = class _CheckboxControlValueAccessor extends BuiltInControlValueAccessor { + /** + * Sets the "checked" property on the input element. + * @docs-private + */ + writeValue(value) { + this.setProperty("checked", value); + } + static ɵfac = /* @__PURE__ */ (() => { + let ɵCheckboxControlValueAccessor_BaseFactory; + return function CheckboxControlValueAccessor_Factory(__ngFactoryType__) { + return (ɵCheckboxControlValueAccessor_BaseFactory || (ɵCheckboxControlValueAccessor_BaseFactory = ɵɵgetInheritedFactory(_CheckboxControlValueAccessor)))(__ngFactoryType__ || _CheckboxControlValueAccessor); + }; + })(); + static ɵdir = ɵɵdefineDirective({ + type: _CheckboxControlValueAccessor, + selectors: [["input", "type", "checkbox", "formControlName", ""], ["input", "type", "checkbox", "formControl", ""], ["input", "type", "checkbox", "ngModel", ""]], + hostBindings: function CheckboxControlValueAccessor_HostBindings(rf, ctx) { + if (rf & 1) { + ɵɵlistener("change", function CheckboxControlValueAccessor_change_HostBindingHandler($event) { + return ctx.onChange($event.target.checked); + })("blur", function CheckboxControlValueAccessor_blur_HostBindingHandler() { + return ctx.onTouched(); + }); + } + }, + standalone: false, + features: [ɵɵProvidersFeature([CHECKBOX_VALUE_ACCESSOR]), ɵɵInheritDefinitionFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(CheckboxControlValueAccessor, [{ + type: Directive, + args: [{ + selector: "input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]", + host: { + "(change)": "onChange($any($event.target).checked)", + "(blur)": "onTouched()" + }, + providers: [CHECKBOX_VALUE_ACCESSOR], + standalone: false + }] + }], null, null); +})(); +var DEFAULT_VALUE_ACCESSOR = { + provide: NG_VALUE_ACCESSOR, + useExisting: forwardRef(() => DefaultValueAccessor), + multi: true +}; +function _isAndroid() { + const userAgent = getDOM() ? getDOM().getUserAgent() : ""; + return /android (\d+)/.test(userAgent.toLowerCase()); +} +var COMPOSITION_BUFFER_MODE = new InjectionToken(ngDevMode ? "CompositionEventMode" : ""); +var DefaultValueAccessor = class _DefaultValueAccessor extends BaseControlValueAccessor { + _compositionMode; + /** Whether the user is creating a composition string (IME events). */ + _composing = false; + constructor(renderer, elementRef, _compositionMode) { + super(renderer, elementRef); + this._compositionMode = _compositionMode; + if (this._compositionMode == null) { + this._compositionMode = !_isAndroid(); + } + } + /** + * Sets the "value" property on the input element. + * @docs-private + */ + writeValue(value) { + const normalizedValue = value == null ? "" : value; + this.setProperty("value", normalizedValue); + } + /** @internal */ + _handleInput(value) { + if (!this._compositionMode || this._compositionMode && !this._composing) { + this.onChange(value); + } + } + /** @internal */ + _compositionStart() { + this._composing = true; + } + /** @internal */ + _compositionEnd(value) { + this._composing = false; + this._compositionMode && this.onChange(value); + } + static ɵfac = function DefaultValueAccessor_Factory(__ngFactoryType__) { + return new (__ngFactoryType__ || _DefaultValueAccessor)(ɵɵdirectiveInject(Renderer2), ɵɵdirectiveInject(ElementRef), ɵɵdirectiveInject(COMPOSITION_BUFFER_MODE, 8)); + }; + static ɵdir = ɵɵdefineDirective({ + type: _DefaultValueAccessor, + selectors: [["input", "formControlName", "", 3, "type", "checkbox"], ["textarea", "formControlName", ""], ["input", "formControl", "", 3, "type", "checkbox"], ["textarea", "formControl", ""], ["input", "ngModel", "", 3, "type", "checkbox"], ["textarea", "ngModel", ""], ["", "ngDefaultControl", ""]], + hostBindings: function DefaultValueAccessor_HostBindings(rf, ctx) { + if (rf & 1) { + ɵɵlistener("input", function DefaultValueAccessor_input_HostBindingHandler($event) { + return ctx._handleInput($event.target.value); + })("blur", function DefaultValueAccessor_blur_HostBindingHandler() { + return ctx.onTouched(); + })("compositionstart", function DefaultValueAccessor_compositionstart_HostBindingHandler() { + return ctx._compositionStart(); + })("compositionend", function DefaultValueAccessor_compositionend_HostBindingHandler($event) { + return ctx._compositionEnd($event.target.value); + }); + } + }, + standalone: false, + features: [ɵɵProvidersFeature([DEFAULT_VALUE_ACCESSOR]), ɵɵInheritDefinitionFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DefaultValueAccessor, [{ + type: Directive, + args: [{ + selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]", + // TODO: vsavkin replace the above selector with the one below it once + // https://github.com/angular/angular/issues/3011 is implemented + // selector: '[ngModel],[formControl],[formControlName]', + host: { + "(input)": "_handleInput($any($event.target).value)", + "(blur)": "onTouched()", + "(compositionstart)": "_compositionStart()", + "(compositionend)": "_compositionEnd($any($event.target).value)" + }, + providers: [DEFAULT_VALUE_ACCESSOR], + standalone: false + }] + }], () => [{ + type: Renderer2 + }, { + type: ElementRef + }, { + type: void 0, + decorators: [{ + type: Optional + }, { + type: Inject, + args: [COMPOSITION_BUFFER_MODE] + }] + }], null); +})(); +function isEmptyInputValue(value) { + return value == null || lengthOrSize(value) === 0; +} +function lengthOrSize(value) { + if (value == null) { + return null; + } else if (Array.isArray(value) || typeof value === "string") { + return value.length; + } else if (value instanceof Set) { + return value.size; + } + return null; +} +var NG_VALIDATORS = new InjectionToken(ngDevMode ? "NgValidators" : ""); +var NG_ASYNC_VALIDATORS = new InjectionToken(ngDevMode ? "NgAsyncValidators" : ""); +var EMAIL_REGEXP = /^(?=.{1,254}$)(?=.{1,64}@)[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/; +var Validators = class { + /** + * @description + * Validator that requires the control's value to be greater than or equal to the provided number. + * + * @usageNotes + * + * ### Validate against a minimum of 3 + * + * ```ts + * const control = new FormControl(2, Validators.min(3)); + * + * console.log(control.errors); // {min: {min: 3, actual: 2}} + * ``` + * + * @returns A validator function that returns an error map with the + * `min` property if the validation check fails, otherwise `null`. + * + * @see {@link /api/forms/AbstractControl#updateValueAndValidity updateValueAndValidity} + * + */ + static min(min) { + return minValidator(min); + } + /** + * @description + * Validator that requires the control's value to be less than or equal to the provided number. + * + * @usageNotes + * + * ### Validate against a maximum of 15 + * + * ```ts + * const control = new FormControl(16, Validators.max(15)); + * + * console.log(control.errors); // {max: {max: 15, actual: 16}} + * ``` + * + * @returns A validator function that returns an error map with the + * `max` property if the validation check fails, otherwise `null`. + * + * @see {@link /api/forms/AbstractControl#updateValueAndValidity updateValueAndValidity} + * + */ + static max(max) { + return maxValidator(max); + } + /** + * @description + * Validator that requires the control have a non-empty value. + * + * @usageNotes + * + * ### Validate that the field is non-empty + * + * ```ts + * const control = new FormControl('', Validators.required); + * + * console.log(control.errors); // {required: true} + * ``` + * + * @returns An error map with the `required` property + * if the validation check fails, otherwise `null`. + * + * @see {@link /api/forms/AbstractControl#updateValueAndValidity updateValueAndValidity} + * + */ + static required(control) { + return requiredValidator(control); + } + /** + * @description + * Validator that requires the control's value be true. This validator is commonly + * used for required checkboxes. + * + * @usageNotes + * + * ### Validate that the field value is true + * + * ```ts + * const control = new FormControl('some value', Validators.requiredTrue); + * + * console.log(control.errors); // {required: true} + * ``` + * + * @returns An error map that contains the `required` property + * set to `true` if the validation check fails, otherwise `null`. + * + * @see {@link /api/forms/AbstractControl#updateValueAndValidity updateValueAndValidity} + * + */ + static requiredTrue(control) { + return requiredTrueValidator(control); + } + /** + * @description + * Validator that requires the control's value pass an email validation test. + * + * Tests the value using a [regular + * expression](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions) + * pattern suitable for common use cases. The pattern is based on the definition of a valid email + * address in the [WHATWG HTML + * specification](https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address) with + * some enhancements to incorporate more RFC rules (such as rules related to domain names and the + * lengths of different parts of the address). + * + * The differences from the WHATWG version include: + * - Disallow `local-part` (the part before the `@` symbol) to begin or end with a period (`.`). + * - Disallow `local-part` to be longer than 64 characters. + * - Disallow the whole address to be longer than 254 characters. + * + * If this pattern does not satisfy your business needs, you can use `Validators.pattern()` to + * validate the value against a different pattern. + * + * @usageNotes + * + * ### Validate that the field matches a valid email pattern + * + * ```ts + * const control = new FormControl('bad@', Validators.email); + * + * console.log(control.errors); // {email: true} + * ``` + * + * @returns An error map with the `email` property + * if the validation check fails, otherwise `null`. + * + * @see {@link /api/forms/AbstractControl#updateValueAndValidity updateValueAndValidity} + * + */ + static email(control) { + return emailValidator(control); + } + /** + * @description + * Validator that requires the number of items in the control's value to be greater than or equal + * to the provided minimum length. This validator is also provided by default if you use + * the HTML5 `minlength` attribute. Note that the `minLength` validator is intended to be used + * only for types that have a numeric `length` or `size` property, such as strings, arrays or + * sets. The `minLength` validator logic is also not invoked for values when their `length` or + * `size` property is 0 (for example in case of an empty string or an empty array), to support + * optional controls. You can use the standard `required` validator if empty values should not be + * considered valid. + * + * @usageNotes + * + * ### Validate that the field has a minimum of 3 characters + * + * ```ts + * const control = new FormControl('ng', Validators.minLength(3)); + * + * console.log(control.errors); // {minlength: {requiredLength: 3, actualLength: 2}} + * ``` + * + * ```html + * + * ``` + * + * @returns A validator function that returns an error map with the + * `minlength` property if the validation check fails, otherwise `null`. + * + * @see {@link /api/forms/AbstractControl#updateValueAndValidity updateValueAndValidity} + * + */ + static minLength(minLength) { + return minLengthValidator(minLength); + } + /** + * @description + * Validator that requires the number of items in the control's value to be less than or equal + * to the provided maximum length. This validator is also provided by default if you use + * the HTML5 `maxlength` attribute. Note that the `maxLength` validator is intended to be used + * only for types that have a numeric `length` or `size` property, such as strings, arrays or + * sets. + * + * @usageNotes + * + * ### Validate that the field has maximum of 5 characters + * + * ```ts + * const control = new FormControl('Angular', Validators.maxLength(5)); + * + * console.log(control.errors); // {maxlength: {requiredLength: 5, actualLength: 7}} + * ``` + * + * ```html + * + * ``` + * + * @returns A validator function that returns an error map with the + * `maxlength` property if the validation check fails, otherwise `null`. + * + * @see {@link /api/forms/AbstractControl#updateValueAndValidity updateValueAndValidity} + * + */ + static maxLength(maxLength) { + return maxLengthValidator(maxLength); + } + /** + * @description + * Validator that requires the control's value to match a regex pattern. This validator is also + * provided by default if you use the HTML5 `pattern` attribute. + * + * @usageNotes + * + * ### Validate that the field only contains letters or spaces + * + * ```ts + * const control = new FormControl('1', Validators.pattern('[a-zA-Z ]*')); + * + * console.log(control.errors); // {pattern: {requiredPattern: '^[a-zA-Z ]*$', actualValue: '1'}} + * ``` + * + * ```html + * + * ``` + * + * ### Pattern matching with the global or sticky flag + * + * `RegExp` objects created with the `g` or `y` flags that are passed into `Validators.pattern` + * can produce different results on the same input when validations are run consecutively. This is + * due to how the behavior of `RegExp.prototype.test` is + * specified in [ECMA-262](https://tc39.es/ecma262/#sec-regexpbuiltinexec) + * (`RegExp` preserves the index of the last match when the global or sticky flag is used). + * Due to this behavior, it is recommended that when using + * `Validators.pattern` you **do not** pass in a `RegExp` object with either the global or sticky + * flag enabled. + * + * ```ts + * // Not recommended (since the `g` flag is used) + * const controlOne = new FormControl('1', Validators.pattern(/foo/g)); + * + * // Good + * const controlTwo = new FormControl('1', Validators.pattern(/foo/)); + * ``` + * + * @param pattern A regular expression to be used as is to test the values, or a string. + * If a string is passed, the `^` character is prepended and the `$` character is + * appended to the provided string (if not already present), and the resulting regular + * expression is used to test the values. + * + * @returns A validator function that returns an error map with the + * `pattern` property if the validation check fails, otherwise `null`. + * + * @see {@link /api/forms/AbstractControl#updateValueAndValidity updateValueAndValidity} + * + */ + static pattern(pattern) { + return patternValidator(pattern); + } + /** + * @description + * Validator that performs no operation. + * + * @see {@link /api/forms/AbstractControl#updateValueAndValidity updateValueAndValidity} + * + */ + static nullValidator(control) { + return nullValidator(); + } + static compose(validators) { + return compose(validators); + } + /** + * @description + * Compose multiple async validators into a single function that returns the union + * of the individual error objects for the provided control. + * + * @returns A validator function that returns an error map with the + * merged error objects of the async validators if the validation check fails, otherwise `null`. + * + * @see {@link /api/forms/AbstractControl#updateValueAndValidity updateValueAndValidity} + * + */ + static composeAsync(validators) { + return composeAsync(validators); + } +}; +function minValidator(min) { + return (control) => { + if (control.value == null || min == null) { + return null; + } + const value = parseFloat(control.value); + return !isNaN(value) && value < min ? { + "min": { + "min": min, + "actual": control.value + } + } : null; + }; +} +function maxValidator(max) { + return (control) => { + if (control.value == null || max == null) { + return null; + } + const value = parseFloat(control.value); + return !isNaN(value) && value > max ? { + "max": { + "max": max, + "actual": control.value + } + } : null; + }; +} +function requiredValidator(control) { + return isEmptyInputValue(control.value) ? { + "required": true + } : null; +} +function requiredTrueValidator(control) { + return control.value === true ? null : { + "required": true + }; +} +function emailValidator(control) { + if (isEmptyInputValue(control.value)) { + return null; + } + return EMAIL_REGEXP.test(control.value) ? null : { + "email": true + }; +} +function minLengthValidator(minLength) { + return (control) => { + const length = control.value?.length ?? lengthOrSize(control.value); + if (length === null || length === 0) { + return null; + } + return length < minLength ? { + "minlength": { + "requiredLength": minLength, + "actualLength": length + } + } : null; + }; +} +function maxLengthValidator(maxLength) { + return (control) => { + const length = control.value?.length ?? lengthOrSize(control.value); + if (length !== null && length > maxLength) { + return { + "maxlength": { + "requiredLength": maxLength, + "actualLength": length + } + }; + } + return null; + }; +} +function patternValidator(pattern) { + if (!pattern) return nullValidator; + let regex; + let regexStr; + if (typeof pattern === "string") { + regexStr = ""; + if (pattern.charAt(0) !== "^") regexStr += "^"; + regexStr += pattern; + if (pattern.charAt(pattern.length - 1) !== "$") regexStr += "$"; + regex = new RegExp(regexStr); + } else { + regexStr = pattern.toString(); + regex = pattern; + } + return (control) => { + if (isEmptyInputValue(control.value)) { + return null; + } + const value = control.value; + return regex.test(value) ? null : { + "pattern": { + "requiredPattern": regexStr, + "actualValue": value + } + }; + }; +} +function nullValidator(control) { + return null; +} +function isPresent(o) { + return o != null; +} +function toObservable(value) { + const obs = isPromise(value) ? from(value) : value; + if ((typeof ngDevMode === "undefined" || ngDevMode) && !isSubscribable(obs)) { + let errorMessage = `Expected async validator to return Promise or Observable.`; + if (typeof value === "object") { + errorMessage += " Are you using a synchronous validator where an async validator is expected?"; + } + throw new RuntimeError(-1101, errorMessage); + } + return obs; +} +function mergeErrors(arrayOfErrors) { + let res = {}; + arrayOfErrors.forEach((errors) => { + res = errors != null ? __spreadValues(__spreadValues({}, res), errors) : res; + }); + return Object.keys(res).length === 0 ? null : res; +} +function executeValidators(control, validators) { + return validators.map((validator) => validator(control)); +} +function isValidatorFn(validator) { + return !validator.validate; +} +function normalizeValidators(validators) { + return validators.map((validator) => { + return isValidatorFn(validator) ? validator : (c) => validator.validate(c); + }); +} +function compose(validators) { + if (!validators) return null; + const presentValidators = validators.filter(isPresent); + if (presentValidators.length == 0) return null; + return function(control) { + return mergeErrors(executeValidators(control, presentValidators)); + }; +} +function composeValidators(validators) { + return validators != null ? compose(normalizeValidators(validators)) : null; +} +function composeAsync(validators) { + if (!validators) return null; + const presentValidators = validators.filter(isPresent); + if (presentValidators.length == 0) return null; + return function(control) { + const observables = executeValidators(control, presentValidators).map(toObservable); + return forkJoin(observables).pipe(map(mergeErrors)); + }; +} +function composeAsyncValidators(validators) { + return validators != null ? composeAsync(normalizeValidators(validators)) : null; +} +function mergeValidators(controlValidators, dirValidator) { + if (controlValidators === null) return [dirValidator]; + return Array.isArray(controlValidators) ? [...controlValidators, dirValidator] : [controlValidators, dirValidator]; +} +function getControlValidators(control) { + return control._rawValidators; +} +function getControlAsyncValidators(control) { + return control._rawAsyncValidators; +} +function makeValidatorsArray(validators) { + if (!validators) return []; + return Array.isArray(validators) ? validators : [validators]; +} +function hasValidator(validators, validator) { + return Array.isArray(validators) ? validators.includes(validator) : validators === validator; +} +function addValidators(validators, currentValidators) { + const current = makeValidatorsArray(currentValidators); + const validatorsToAdd = makeValidatorsArray(validators); + validatorsToAdd.forEach((v) => { + if (!hasValidator(current, v)) { + current.push(v); + } + }); + return current; +} +function removeValidators(validators, currentValidators) { + return makeValidatorsArray(currentValidators).filter((v) => !hasValidator(validators, v)); +} +var AbstractControlDirective = class { + /** + * @description + * Reports the value of the control if it is present, otherwise null. + */ + get value() { + return this.control ? this.control.value : null; + } + /** + * @description + * Reports whether the control is valid. A control is considered valid if no + * validation errors exist with the current value. + * If the control is not present, null is returned. + */ + get valid() { + return this.control ? this.control.valid : null; + } + /** + * @description + * Reports whether the control is invalid, meaning that an error exists in the input value. + * If the control is not present, null is returned. + */ + get invalid() { + return this.control ? this.control.invalid : null; + } + /** + * @description + * Reports whether a control is pending, meaning that async validation is occurring and + * errors are not yet available for the input value. If the control is not present, null is + * returned. + */ + get pending() { + return this.control ? this.control.pending : null; + } + /** + * @description + * Reports whether the control is disabled, meaning that the control is disabled + * in the UI and is exempt from validation checks and excluded from aggregate + * values of ancestor controls. If the control is not present, null is returned. + */ + get disabled() { + return this.control ? this.control.disabled : null; + } + /** + * @description + * Reports whether the control is enabled, meaning that the control is included in ancestor + * calculations of validity or value. If the control is not present, null is returned. + */ + get enabled() { + return this.control ? this.control.enabled : null; + } + /** + * @description + * Reports the control's validation errors. If the control is not present, null is returned. + */ + get errors() { + return this.control ? this.control.errors : null; + } + /** + * @description + * Reports whether the control is pristine, meaning that the user has not yet changed + * the value in the UI. If the control is not present, null is returned. + */ + get pristine() { + return this.control ? this.control.pristine : null; + } + /** + * @description + * Reports whether the control is dirty, meaning that the user has changed + * the value in the UI. If the control is not present, null is returned. + */ + get dirty() { + return this.control ? this.control.dirty : null; + } + /** + * @description + * Reports whether the control is touched, meaning that the user has triggered + * a `blur` event on it. If the control is not present, null is returned. + */ + get touched() { + return this.control ? this.control.touched : null; + } + /** + * @description + * Reports the validation status of the control. Possible values include: + * 'VALID', 'INVALID', 'DISABLED', and 'PENDING'. + * If the control is not present, null is returned. + */ + get status() { + return this.control ? this.control.status : null; + } + /** + * @description + * Reports whether the control is untouched, meaning that the user has not yet triggered + * a `blur` event on it. If the control is not present, null is returned. + */ + get untouched() { + return this.control ? this.control.untouched : null; + } + /** + * @description + * Returns a multicasting observable that emits a validation status whenever it is + * calculated for the control. If the control is not present, null is returned. + */ + get statusChanges() { + return this.control ? this.control.statusChanges : null; + } + /** + * @description + * Returns a multicasting observable of value changes for the control that emits every time the + * value of the control changes in the UI or programmatically. + * If the control is not present, null is returned. + */ + get valueChanges() { + return this.control ? this.control.valueChanges : null; + } + /** + * @description + * Returns an array that represents the path from the top-level form to this control. + * Each index is the string name of the control on that level. + */ + get path() { + return null; + } + /** + * Contains the result of merging synchronous validators into a single validator function + * (combined using `Validators.compose`). + */ + _composedValidatorFn; + /** + * Contains the result of merging asynchronous validators into a single validator function + * (combined using `Validators.composeAsync`). + */ + _composedAsyncValidatorFn; + /** + * Set of synchronous validators as they were provided while calling `setValidators` function. + * @internal + */ + _rawValidators = []; + /** + * Set of asynchronous validators as they were provided while calling `setAsyncValidators` + * function. + * @internal + */ + _rawAsyncValidators = []; + /** + * Sets synchronous validators for this directive. + * @internal + */ + _setValidators(validators) { + this._rawValidators = validators || []; + this._composedValidatorFn = composeValidators(this._rawValidators); + } + /** + * Sets asynchronous validators for this directive. + * @internal + */ + _setAsyncValidators(validators) { + this._rawAsyncValidators = validators || []; + this._composedAsyncValidatorFn = composeAsyncValidators(this._rawAsyncValidators); + } + /** + * @description + * Synchronous validator function composed of all the synchronous validators registered with this + * directive. + */ + get validator() { + return this._composedValidatorFn || null; + } + /** + * @description + * Asynchronous validator function composed of all the asynchronous validators registered with + * this directive. + */ + get asyncValidator() { + return this._composedAsyncValidatorFn || null; + } + /* + * The set of callbacks to be invoked when directive instance is being destroyed. + */ + _onDestroyCallbacks = []; + /** + * Internal function to register callbacks that should be invoked + * when directive instance is being destroyed. + * @internal + */ + _registerOnDestroy(fn) { + this._onDestroyCallbacks.push(fn); + } + /** + * Internal function to invoke all registered "on destroy" callbacks. + * Note: calling this function also clears the list of callbacks. + * @internal + */ + _invokeOnDestroyCallbacks() { + this._onDestroyCallbacks.forEach((fn) => fn()); + this._onDestroyCallbacks = []; + } + /** + * @description + * Resets the control with the provided value if the control is present. + */ + reset(value = void 0) { + if (this.control) this.control.reset(value); + } + /** + * @description + * Reports whether the control with the given path has the error specified. + * + * @param errorCode The code of the error to check + * @param path A list of control names that designates how to move from the current control + * to the control that should be queried for errors. + * + * @usageNotes + * For example, for the following `FormGroup`: + * + * ```ts + * form = new FormGroup({ + * address: new FormGroup({ street: new FormControl() }) + * }); + * ``` + * + * The path to the 'street' control from the root form would be 'address' -> 'street'. + * + * It can be provided to this method in one of two formats: + * + * 1. An array of string control names, e.g. `['address', 'street']` + * 1. A period-delimited list of control names in one string, e.g. `'address.street'` + * + * If no path is given, this method checks for the error on the current control. + * + * @returns whether the given error is present in the control at the given path. + * + * If the control is not present, false is returned. + */ + hasError(errorCode, path) { + return this.control ? this.control.hasError(errorCode, path) : false; + } + /** + * @description + * Reports error data for the control with the given path. + * + * @param errorCode The code of the error to check + * @param path A list of control names that designates how to move from the current control + * to the control that should be queried for errors. + * + * @usageNotes + * For example, for the following `FormGroup`: + * + * ```ts + * form = new FormGroup({ + * address: new FormGroup({ street: new FormControl() }) + * }); + * ``` + * + * The path to the 'street' control from the root form would be 'address' -> 'street'. + * + * It can be provided to this method in one of two formats: + * + * 1. An array of string control names, e.g. `['address', 'street']` + * 1. A period-delimited list of control names in one string, e.g. `'address.street'` + * + * @returns error data for that particular error. If the control or error is not present, + * null is returned. + */ + getError(errorCode, path) { + return this.control ? this.control.getError(errorCode, path) : null; + } +}; +var ControlContainer = class extends AbstractControlDirective { + /** + * @description + * The name for the control + */ + name; + /** + * @description + * The top-level form directive for the control. + */ + get formDirective() { + return null; + } + /** + * @description + * The path to this group. + */ + get path() { + return null; + } +}; +var NgControl = class extends AbstractControlDirective { + /** + * @description + * The parent form for the control. + * + * @internal + */ + _parent = null; + /** + * @description + * The name for the control + */ + name = null; + /** + * @description + * The value accessor for the control + */ + valueAccessor = null; +}; +var AbstractControlStatus = class { + _cd; + constructor(cd) { + this._cd = cd; + } + get isTouched() { + this._cd?.control?._touched?.(); + return !!this._cd?.control?.touched; + } + get isUntouched() { + return !!this._cd?.control?.untouched; + } + get isPristine() { + this._cd?.control?._pristine?.(); + return !!this._cd?.control?.pristine; + } + get isDirty() { + return !!this._cd?.control?.dirty; + } + get isValid() { + this._cd?.control?._status?.(); + return !!this._cd?.control?.valid; + } + get isInvalid() { + return !!this._cd?.control?.invalid; + } + get isPending() { + return !!this._cd?.control?.pending; + } + get isSubmitted() { + this._cd?._submitted?.(); + return !!this._cd?.submitted; + } +}; +var ngControlStatusHost = { + "[class.ng-untouched]": "isUntouched", + "[class.ng-touched]": "isTouched", + "[class.ng-pristine]": "isPristine", + "[class.ng-dirty]": "isDirty", + "[class.ng-valid]": "isValid", + "[class.ng-invalid]": "isInvalid", + "[class.ng-pending]": "isPending" +}; +var ngGroupStatusHost = __spreadProps(__spreadValues({}, ngControlStatusHost), { + "[class.ng-submitted]": "isSubmitted" +}); +var NgControlStatus = class _NgControlStatus extends AbstractControlStatus { + constructor(cd) { + super(cd); + } + static ɵfac = function NgControlStatus_Factory(__ngFactoryType__) { + return new (__ngFactoryType__ || _NgControlStatus)(ɵɵdirectiveInject(NgControl, 2)); + }; + static ɵdir = ɵɵdefineDirective({ + type: _NgControlStatus, + selectors: [["", "formControlName", ""], ["", "ngModel", ""], ["", "formControl", ""]], + hostVars: 14, + hostBindings: function NgControlStatus_HostBindings(rf, ctx) { + if (rf & 2) { + ɵɵclassProp("ng-untouched", ctx.isUntouched)("ng-touched", ctx.isTouched)("ng-pristine", ctx.isPristine)("ng-dirty", ctx.isDirty)("ng-valid", ctx.isValid)("ng-invalid", ctx.isInvalid)("ng-pending", ctx.isPending); + } + }, + standalone: false, + features: [ɵɵInheritDefinitionFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgControlStatus, [{ + type: Directive, + args: [{ + selector: "[formControlName],[ngModel],[formControl]", + host: ngControlStatusHost, + standalone: false + }] + }], () => [{ + type: NgControl, + decorators: [{ + type: Self + }] + }], null); +})(); +var NgControlStatusGroup = class _NgControlStatusGroup extends AbstractControlStatus { + constructor(cd) { + super(cd); + } + static ɵfac = function NgControlStatusGroup_Factory(__ngFactoryType__) { + return new (__ngFactoryType__ || _NgControlStatusGroup)(ɵɵdirectiveInject(ControlContainer, 10)); + }; + static ɵdir = ɵɵdefineDirective({ + type: _NgControlStatusGroup, + selectors: [["", "formGroupName", ""], ["", "formArrayName", ""], ["", "ngModelGroup", ""], ["", "formGroup", ""], ["form", 3, "ngNoForm", ""], ["", "ngForm", ""]], + hostVars: 16, + hostBindings: function NgControlStatusGroup_HostBindings(rf, ctx) { + if (rf & 2) { + ɵɵclassProp("ng-untouched", ctx.isUntouched)("ng-touched", ctx.isTouched)("ng-pristine", ctx.isPristine)("ng-dirty", ctx.isDirty)("ng-valid", ctx.isValid)("ng-invalid", ctx.isInvalid)("ng-pending", ctx.isPending)("ng-submitted", ctx.isSubmitted); + } + }, + standalone: false, + features: [ɵɵInheritDefinitionFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgControlStatusGroup, [{ + type: Directive, + args: [{ + selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]", + host: ngGroupStatusHost, + standalone: false + }] + }], () => [{ + type: ControlContainer, + decorators: [{ + type: Optional + }, { + type: Self + }] + }], null); +})(); +var formControlNameExample = ` +
+ +
+ + In your class: + + this.myGroup = new FormGroup({ + firstName: new FormControl() + });`; +var formGroupNameExample = ` +
+
+ +
+
+ + In your class: + + this.myGroup = new FormGroup({ + person: new FormGroup({ firstName: new FormControl() }) + });`; +var formArrayNameExample = ` +
+
+
+ +
+
+
+ + In your class: + + this.cityArray = new FormArray([new FormControl('SF')]); + this.myGroup = new FormGroup({ + cities: this.cityArray + });`; +var ngModelGroupExample = ` +
+
+ +
+
`; +var ngModelWithFormGroupExample = ` +
+ + +
+`; +function controlParentException(nameOrIndex) { + return new RuntimeError(1050, `formControlName must be used with a parent formGroup directive. You'll want to add a formGroup + directive and pass it an existing FormGroup instance (you can create one in your class). + + ${describeFormControl(nameOrIndex)} + + Example: + + ${formControlNameExample}`); +} +function describeFormControl(nameOrIndex) { + if (nameOrIndex == null || nameOrIndex === "") { + return ""; + } + const valueType = typeof nameOrIndex === "string" ? "name" : "index"; + return `Affected Form Control ${valueType}: "${nameOrIndex}"`; +} +function ngModelGroupException() { + return new RuntimeError(1051, `formControlName cannot be used with an ngModelGroup parent. It is only compatible with parents + that also have a "form" prefix: formGroupName, formArrayName, or formGroup. + + Option 1: Update the parent to be formGroupName (reactive form strategy) + + ${formGroupNameExample} + + Option 2: Use ngModel instead of formControlName (template-driven strategy) + + ${ngModelGroupExample}`); +} +function missingFormException() { + return new RuntimeError(1052, `formGroup expects a FormGroup instance. Please pass one in. + + Example: + + ${formControlNameExample}`); +} +function groupParentException() { + return new RuntimeError(1053, `formGroupName must be used with a parent formGroup directive. You'll want to add a formGroup + directive and pass it an existing FormGroup instance (you can create one in your class). + + Example: + + ${formGroupNameExample}`); +} +function arrayParentException() { + return new RuntimeError(1054, `formArrayName must be used with a parent formGroup directive. You'll want to add a formGroup + directive and pass it an existing FormGroup instance (you can create one in your class). + + Example: + + ${formArrayNameExample}`); +} +var disabledAttrWarning = ` + It looks like you're using the disabled attribute with a reactive form directive. If you set disabled to true + when you set up this control in your component class, the disabled attribute will actually be set in the DOM for + you. We recommend using this approach to avoid 'changed after checked' errors. + + Example: + // Specify the \`disabled\` property at control creation time: + form = new FormGroup({ + first: new FormControl({value: 'Nancy', disabled: true}, Validators.required), + last: new FormControl('Drew', Validators.required) + }); + + // Controls can also be enabled/disabled after creation: + form.get('first')?.enable(); + form.get('last')?.disable(); +`; +var asyncValidatorsDroppedWithOptsWarning = ` + It looks like you're constructing using a FormControl with both an options argument and an + async validators argument. Mixing these arguments will cause your async validators to be dropped. + You should either put all your validators in the options object, or in separate validators + arguments. For example: + + // Using validators arguments + fc = new FormControl(42, Validators.required, myAsyncValidator); + + // Using AbstractControlOptions + fc = new FormControl(42, {validators: Validators.required, asyncValidators: myAV}); + + // Do NOT mix them: async validators will be dropped! + fc = new FormControl(42, {validators: Validators.required}, /* Oops! */ myAsyncValidator); +`; +function ngModelWarning(directiveName) { + return ` + It looks like you're using ngModel on the same form field as ${directiveName}. + Support for using the ngModel input property and ngModelChange event with + reactive form directives has been deprecated in Angular v6 and will be removed + in a future version of Angular. + + For more information on this, see our API docs here: + https://angular.io/api/forms/${directiveName === "formControl" ? "FormControlDirective" : "FormControlName"}#use-with-ngmodel + `; +} +function describeKey(isFormGroup2, key) { + return isFormGroup2 ? `with name: '${key}'` : `at index: ${key}`; +} +function noControlsError(isFormGroup2) { + return ` + There are no form controls registered with this ${isFormGroup2 ? "group" : "array"} yet. If you're using ngModel, + you may want to check next tick (e.g. use setTimeout). + `; +} +function missingControlError(isFormGroup2, key) { + return `Cannot find form control ${describeKey(isFormGroup2, key)}`; +} +function missingControlValueError(isFormGroup2, key) { + return `Must supply a value for form control ${describeKey(isFormGroup2, key)}`; +} +var VALID = "VALID"; +var INVALID = "INVALID"; +var PENDING = "PENDING"; +var DISABLED = "DISABLED"; +var ControlEvent = class { +}; +var ValueChangeEvent = class extends ControlEvent { + value; + source; + constructor(value, source) { + super(); + this.value = value; + this.source = source; + } +}; +var PristineChangeEvent = class extends ControlEvent { + pristine; + source; + constructor(pristine, source) { + super(); + this.pristine = pristine; + this.source = source; + } +}; +var TouchedChangeEvent = class extends ControlEvent { + touched; + source; + constructor(touched, source) { + super(); + this.touched = touched; + this.source = source; + } +}; +var StatusChangeEvent = class extends ControlEvent { + status; + source; + constructor(status, source) { + super(); + this.status = status; + this.source = source; + } +}; +var FormSubmittedEvent = class extends ControlEvent { + source; + constructor(source) { + super(); + this.source = source; + } +}; +var FormResetEvent = class extends ControlEvent { + source; + constructor(source) { + super(); + this.source = source; + } +}; +function pickValidators(validatorOrOpts) { + return (isOptionsObj(validatorOrOpts) ? validatorOrOpts.validators : validatorOrOpts) || null; +} +function coerceToValidator(validator) { + return Array.isArray(validator) ? composeValidators(validator) : validator || null; +} +function pickAsyncValidators(asyncValidator, validatorOrOpts) { + if (typeof ngDevMode === "undefined" || ngDevMode) { + if (isOptionsObj(validatorOrOpts) && asyncValidator) { + console.warn(asyncValidatorsDroppedWithOptsWarning); + } + } + return (isOptionsObj(validatorOrOpts) ? validatorOrOpts.asyncValidators : asyncValidator) || null; +} +function coerceToAsyncValidator(asyncValidator) { + return Array.isArray(asyncValidator) ? composeAsyncValidators(asyncValidator) : asyncValidator || null; +} +function isOptionsObj(validatorOrOpts) { + return validatorOrOpts != null && !Array.isArray(validatorOrOpts) && typeof validatorOrOpts === "object"; +} +function assertControlPresent(parent, isGroup, key) { + const controls = parent.controls; + const collection = isGroup ? Object.keys(controls) : controls; + if (!collection.length) { + throw new RuntimeError(1e3, typeof ngDevMode === "undefined" || ngDevMode ? noControlsError(isGroup) : ""); + } + if (!controls[key]) { + throw new RuntimeError(1001, typeof ngDevMode === "undefined" || ngDevMode ? missingControlError(isGroup, key) : ""); + } +} +function assertAllValuesPresent(control, isGroup, value) { + control._forEachChild((_, key) => { + if (value[key] === void 0) { + throw new RuntimeError(1002, typeof ngDevMode === "undefined" || ngDevMode ? missingControlValueError(isGroup, key) : ""); + } + }); +} +var AbstractControl = class { + /** @internal */ + _pendingDirty = false; + /** + * Indicates that a control has its own pending asynchronous validation in progress. + * It also stores if the control should emit events when the validation status changes. + * + * @internal + */ + _hasOwnPendingAsyncValidator = null; + /** @internal */ + _pendingTouched = false; + /** @internal */ + _onCollectionChange = () => { + }; + /** @internal */ + _updateOn; + _parent = null; + _asyncValidationSubscription; + /** + * Contains the result of merging synchronous validators into a single validator function + * (combined using `Validators.compose`). + * + * @internal + */ + _composedValidatorFn; + /** + * Contains the result of merging asynchronous validators into a single validator function + * (combined using `Validators.composeAsync`). + * + * @internal + */ + _composedAsyncValidatorFn; + /** + * Synchronous validators as they were provided: + * - in `AbstractControl` constructor + * - as an argument while calling `setValidators` function + * - while calling the setter on the `validator` field (e.g. `control.validator = validatorFn`) + * + * @internal + */ + _rawValidators; + /** + * Asynchronous validators as they were provided: + * - in `AbstractControl` constructor + * - as an argument while calling `setAsyncValidators` function + * - while calling the setter on the `asyncValidator` field (e.g. `control.asyncValidator = + * asyncValidatorFn`) + * + * @internal + */ + _rawAsyncValidators; + /** + * The current value of the control. + * + * * For a `FormControl`, the current value. + * * For an enabled `FormGroup`, the values of enabled controls as an object + * with a key-value pair for each member of the group. + * * For a disabled `FormGroup`, the values of all controls as an object + * with a key-value pair for each member of the group. + * * For a `FormArray`, the values of enabled controls as an array. + * + */ + value; + /** + * Initialize the AbstractControl instance. + * + * @param validators The function or array of functions that is used to determine the validity of + * this control synchronously. + * @param asyncValidators The function or array of functions that is used to determine validity of + * this control asynchronously. + */ + constructor(validators, asyncValidators) { + this._assignValidators(validators); + this._assignAsyncValidators(asyncValidators); + } + /** + * Returns the function that is used to determine the validity of this control synchronously. + * If multiple validators have been added, this will be a single composed function. + * See `Validators.compose()` for additional information. + */ + get validator() { + return this._composedValidatorFn; + } + set validator(validatorFn) { + this._rawValidators = this._composedValidatorFn = validatorFn; + } + /** + * Returns the function that is used to determine the validity of this control asynchronously. + * If multiple validators have been added, this will be a single composed function. + * See `Validators.compose()` for additional information. + */ + get asyncValidator() { + return this._composedAsyncValidatorFn; + } + set asyncValidator(asyncValidatorFn) { + this._rawAsyncValidators = this._composedAsyncValidatorFn = asyncValidatorFn; + } + /** + * The parent control. + */ + get parent() { + return this._parent; + } + /** + * The validation status of the control. + * + * @see {@link FormControlStatus} + * + * These status values are mutually exclusive, so a control cannot be + * both valid AND invalid or invalid AND disabled. + */ + get status() { + return untracked(this.statusReactive); + } + set status(v) { + untracked(() => this.statusReactive.set(v)); + } + /** @internal */ + _status = computed(() => this.statusReactive(), ...ngDevMode ? [{ + debugName: "_status" + }] : []); + statusReactive = signal(void 0, ...ngDevMode ? [{ + debugName: "statusReactive" + }] : []); + /** + * A control is `valid` when its `status` is `VALID`. + * + * @see {@link AbstractControl.status} + * + * @returns True if the control has passed all of its validation tests, + * false otherwise. + */ + get valid() { + return this.status === VALID; + } + /** + * A control is `invalid` when its `status` is `INVALID`. + * + * @see {@link AbstractControl.status} + * + * @returns True if this control has failed one or more of its validation checks, + * false otherwise. + */ + get invalid() { + return this.status === INVALID; + } + /** + * A control is `pending` when its `status` is `PENDING`. + * + * @see {@link AbstractControl.status} + * + * @returns True if this control is in the process of conducting a validation check, + * false otherwise. + */ + get pending() { + return this.status == PENDING; + } + /** + * A control is `disabled` when its `status` is `DISABLED`. + * + * Disabled controls are exempt from validation checks and + * are not included in the aggregate value of their ancestor + * controls. + * + * @see {@link AbstractControl.status} + * + * @returns True if the control is disabled, false otherwise. + */ + get disabled() { + return this.status === DISABLED; + } + /** + * A control is `enabled` as long as its `status` is not `DISABLED`. + * + * @returns True if the control has any status other than 'DISABLED', + * false if the status is 'DISABLED'. + * + * @see {@link AbstractControl.status} + * + */ + get enabled() { + return this.status !== DISABLED; + } + /** + * An object containing any errors generated by failing validation, + * or null if there are no errors. + */ + errors; + /** + * A control is `pristine` if the user has not yet changed + * the value in the UI. + * + * @returns True if the user has not yet changed the value in the UI; compare `dirty`. + * Programmatic changes to a control's value do not mark it dirty. + */ + get pristine() { + return untracked(this.pristineReactive); + } + set pristine(v) { + untracked(() => this.pristineReactive.set(v)); + } + /** @internal */ + _pristine = computed(() => this.pristineReactive(), ...ngDevMode ? [{ + debugName: "_pristine" + }] : []); + pristineReactive = signal(true, ...ngDevMode ? [{ + debugName: "pristineReactive" + }] : []); + /** + * A control is `dirty` if the user has changed the value + * in the UI. + * + * @returns True if the user has changed the value of this control in the UI; compare `pristine`. + * Programmatic changes to a control's value do not mark it dirty. + */ + get dirty() { + return !this.pristine; + } + /** + * True if the control is marked as `touched`. + * + * A control is marked `touched` once the user has triggered + * a `blur` event on it. + */ + get touched() { + return untracked(this.touchedReactive); + } + set touched(v) { + untracked(() => this.touchedReactive.set(v)); + } + /** @internal */ + _touched = computed(() => this.touchedReactive(), ...ngDevMode ? [{ + debugName: "_touched" + }] : []); + touchedReactive = signal(false, ...ngDevMode ? [{ + debugName: "touchedReactive" + }] : []); + /** + * True if the control has not been marked as touched + * + * A control is `untouched` if the user has not yet triggered + * a `blur` event on it. + */ + get untouched() { + return !this.touched; + } + /** + * Exposed as observable, see below. + * + * @internal + */ + _events = new Subject(); + /** + * A multicasting observable that emits an event every time the state of the control changes. + * It emits for value, status, pristine or touched changes. + * + * **Note**: On value change, the emit happens right after a value of this control is updated. The + * value of a parent control (for example if this FormControl is a part of a FormGroup) is updated + * later, so accessing a value of a parent control (using the `value` property) from the callback + * of this event might result in getting a value that has not been updated yet. Subscribe to the + * `events` of the parent control instead. + * For other event types, the events are emitted after the parent control has been updated. + * + */ + events = this._events.asObservable(); + /** + * A multicasting observable that emits an event every time the value of the control changes, in + * the UI or programmatically. It also emits an event each time you call enable() or disable() + * without passing along {emitEvent: false} as a function argument. + * + * **Note**: the emit happens right after a value of this control is updated. The value of a + * parent control (for example if this FormControl is a part of a FormGroup) is updated later, so + * accessing a value of a parent control (using the `value` property) from the callback of this + * event might result in getting a value that has not been updated yet. Subscribe to the + * `valueChanges` event of the parent control instead. + */ + valueChanges; + /** + * A multicasting observable that emits an event every time the validation `status` of the control + * recalculates. + * + * @see {@link FormControlStatus} + * @see {@link AbstractControl.status} + */ + statusChanges; + /** + * Reports the update strategy of the `AbstractControl` (meaning + * the event on which the control updates itself). + * Possible values: `'change'` | `'blur'` | `'submit'` + * Default value: `'change'` + */ + get updateOn() { + return this._updateOn ? this._updateOn : this.parent ? this.parent.updateOn : "change"; + } + /** + * Sets the synchronous validators that are active on this control. Calling + * this overwrites any existing synchronous validators. + * + * When you add or remove a validator at run time, you must call + * `updateValueAndValidity()` for the new validation to take effect. + * + * If you want to add a new validator without affecting existing ones, consider + * using `addValidators()` method instead. + */ + setValidators(validators) { + this._assignValidators(validators); + } + /** + * Sets the asynchronous validators that are active on this control. Calling this + * overwrites any existing asynchronous validators. + * + * When you add or remove a validator at run time, you must call + * `updateValueAndValidity()` for the new validation to take effect. + * + * If you want to add a new validator without affecting existing ones, consider + * using `addAsyncValidators()` method instead. + */ + setAsyncValidators(validators) { + this._assignAsyncValidators(validators); + } + /** + * Add a synchronous validator or validators to this control, without affecting other validators. + * + * When you add or remove a validator at run time, you must call + * `updateValueAndValidity()` for the new validation to take effect. + * + * Adding a validator that already exists will have no effect. If duplicate validator functions + * are present in the `validators` array, only the first instance would be added to a form + * control. + * + * @param validators The new validator function or functions to add to this control. + */ + addValidators(validators) { + this.setValidators(addValidators(validators, this._rawValidators)); + } + /** + * Add an asynchronous validator or validators to this control, without affecting other + * validators. + * + * When you add or remove a validator at run time, you must call + * `updateValueAndValidity()` for the new validation to take effect. + * + * Adding a validator that already exists will have no effect. + * + * @param validators The new asynchronous validator function or functions to add to this control. + */ + addAsyncValidators(validators) { + this.setAsyncValidators(addValidators(validators, this._rawAsyncValidators)); + } + /** + * Remove a synchronous validator from this control, without affecting other validators. + * Validators are compared by function reference; you must pass a reference to the exact same + * validator function as the one that was originally set. If a provided validator is not found, + * it is ignored. + * + * @usageNotes + * + * ### Reference to a ValidatorFn + * + * ``` + * // Reference to the RequiredValidator + * const ctrl = new FormControl('', Validators.required); + * ctrl.removeValidators(Validators.required); + * + * // Reference to anonymous function inside MinValidator + * const minValidator = Validators.min(3); + * const ctrl = new FormControl('', minValidator); + * expect(ctrl.hasValidator(minValidator)).toEqual(true) + * expect(ctrl.hasValidator(Validators.min(3))).toEqual(false) + * + * ctrl.removeValidators(minValidator); + * ``` + * + * When you add or remove a validator at run time, you must call + * `updateValueAndValidity()` for the new validation to take effect. + * + * @param validators The validator or validators to remove. + */ + removeValidators(validators) { + this.setValidators(removeValidators(validators, this._rawValidators)); + } + /** + * Remove an asynchronous validator from this control, without affecting other validators. + * Validators are compared by function reference; you must pass a reference to the exact same + * validator function as the one that was originally set. If a provided validator is not found, it + * is ignored. + * + * When you add or remove a validator at run time, you must call + * `updateValueAndValidity()` for the new validation to take effect. + * + * @param validators The asynchronous validator or validators to remove. + */ + removeAsyncValidators(validators) { + this.setAsyncValidators(removeValidators(validators, this._rawAsyncValidators)); + } + /** + * Check whether a synchronous validator function is present on this control. The provided + * validator must be a reference to the exact same function that was provided. + * + * @usageNotes + * + * ### Reference to a ValidatorFn + * + * ``` + * // Reference to the RequiredValidator + * const ctrl = new FormControl(0, Validators.required); + * expect(ctrl.hasValidator(Validators.required)).toEqual(true) + * + * // Reference to anonymous function inside MinValidator + * const minValidator = Validators.min(3); + * const ctrl = new FormControl(0, minValidator); + * expect(ctrl.hasValidator(minValidator)).toEqual(true) + * expect(ctrl.hasValidator(Validators.min(3))).toEqual(false) + * ``` + * + * @param validator The validator to check for presence. Compared by function reference. + * @returns Whether the provided validator was found on this control. + */ + hasValidator(validator) { + return hasValidator(this._rawValidators, validator); + } + /** + * Check whether an asynchronous validator function is present on this control. The provided + * validator must be a reference to the exact same function that was provided. + * + * @param validator The asynchronous validator to check for presence. Compared by function + * reference. + * @returns Whether the provided asynchronous validator was found on this control. + */ + hasAsyncValidator(validator) { + return hasValidator(this._rawAsyncValidators, validator); + } + /** + * Empties out the synchronous validator list. + * + * When you add or remove a validator at run time, you must call + * `updateValueAndValidity()` for the new validation to take effect. + * + */ + clearValidators() { + this.validator = null; + } + /** + * Empties out the async validator list. + * + * When you add or remove a validator at run time, you must call + * `updateValueAndValidity()` for the new validation to take effect. + * + */ + clearAsyncValidators() { + this.asyncValidator = null; + } + markAsTouched(opts = {}) { + const changed = this.touched === false; + this.touched = true; + const sourceControl = opts.sourceControl ?? this; + if (this._parent && !opts.onlySelf) { + this._parent.markAsTouched(__spreadProps(__spreadValues({}, opts), { + sourceControl + })); + } + if (changed && opts.emitEvent !== false) { + this._events.next(new TouchedChangeEvent(true, sourceControl)); + } + } + /** + * Marks the control and all its descendant controls as `dirty`. + * @see {@link markAsDirty()} + * + * @param opts Configuration options that determine how the control propagates changes + * and emits events after marking is applied. + * * `emitEvent`: When true or not supplied (the default), the `events` + * observable emits a `PristineChangeEvent` with the `pristine` property being `false`. + * When false, no events are emitted. + */ + markAllAsDirty(opts = {}) { + this.markAsDirty({ + onlySelf: true, + emitEvent: opts.emitEvent, + sourceControl: this + }); + this._forEachChild((control) => control.markAllAsDirty(opts)); + } + /** + * Marks the control and all its descendant controls as `touched`. + * @see {@link markAsTouched()} + * + * @param opts Configuration options that determine how the control propagates changes + * and emits events after marking is applied. + * * `emitEvent`: When true or not supplied (the default), the `events` + * observable emits a `TouchedChangeEvent` with the `touched` property being `true`. + * When false, no events are emitted. + */ + markAllAsTouched(opts = {}) { + this.markAsTouched({ + onlySelf: true, + emitEvent: opts.emitEvent, + sourceControl: this + }); + this._forEachChild((control) => control.markAllAsTouched(opts)); + } + markAsUntouched(opts = {}) { + const changed = this.touched === true; + this.touched = false; + this._pendingTouched = false; + const sourceControl = opts.sourceControl ?? this; + this._forEachChild((control) => { + control.markAsUntouched({ + onlySelf: true, + emitEvent: opts.emitEvent, + sourceControl + }); + }); + if (this._parent && !opts.onlySelf) { + this._parent._updateTouched(opts, sourceControl); + } + if (changed && opts.emitEvent !== false) { + this._events.next(new TouchedChangeEvent(false, sourceControl)); + } + } + markAsDirty(opts = {}) { + const changed = this.pristine === true; + this.pristine = false; + const sourceControl = opts.sourceControl ?? this; + if (this._parent && !opts.onlySelf) { + this._parent.markAsDirty(__spreadProps(__spreadValues({}, opts), { + sourceControl + })); + } + if (changed && opts.emitEvent !== false) { + this._events.next(new PristineChangeEvent(false, sourceControl)); + } + } + markAsPristine(opts = {}) { + const changed = this.pristine === false; + this.pristine = true; + this._pendingDirty = false; + const sourceControl = opts.sourceControl ?? this; + this._forEachChild((control) => { + control.markAsPristine({ + onlySelf: true, + emitEvent: opts.emitEvent + }); + }); + if (this._parent && !opts.onlySelf) { + this._parent._updatePristine(opts, sourceControl); + } + if (changed && opts.emitEvent !== false) { + this._events.next(new PristineChangeEvent(true, sourceControl)); + } + } + markAsPending(opts = {}) { + this.status = PENDING; + const sourceControl = opts.sourceControl ?? this; + if (opts.emitEvent !== false) { + this._events.next(new StatusChangeEvent(this.status, sourceControl)); + this.statusChanges.emit(this.status); + } + if (this._parent && !opts.onlySelf) { + this._parent.markAsPending(__spreadProps(__spreadValues({}, opts), { + sourceControl + })); + } + } + disable(opts = {}) { + const skipPristineCheck = this._parentMarkedDirty(opts.onlySelf); + this.status = DISABLED; + this.errors = null; + this._forEachChild((control) => { + control.disable(__spreadProps(__spreadValues({}, opts), { + onlySelf: true + })); + }); + this._updateValue(); + const sourceControl = opts.sourceControl ?? this; + if (opts.emitEvent !== false) { + this._events.next(new ValueChangeEvent(this.value, sourceControl)); + this._events.next(new StatusChangeEvent(this.status, sourceControl)); + this.valueChanges.emit(this.value); + this.statusChanges.emit(this.status); + } + this._updateAncestors(__spreadProps(__spreadValues({}, opts), { + skipPristineCheck + }), this); + this._onDisabledChange.forEach((changeFn) => changeFn(true)); + } + /** + * Enables the control. This means the control is included in validation checks and + * the aggregate value of its parent. Its status recalculates based on its value and + * its validators. + * + * By default, if the control has children, all children are enabled. + * + * @see {@link AbstractControl.status} + * + * @param opts Configure options that control how the control propagates changes and + * emits events when marked as untouched + * * `onlySelf`: When true, mark only this control. When false or not supplied, + * marks all direct ancestors. Default is false. + * * `emitEvent`: When true or not supplied (the default), the `statusChanges`, + * `valueChanges` and `events` + * observables emit events with the latest status and value when the control is enabled. + * When false, no events are emitted. + */ + enable(opts = {}) { + const skipPristineCheck = this._parentMarkedDirty(opts.onlySelf); + this.status = VALID; + this._forEachChild((control) => { + control.enable(__spreadProps(__spreadValues({}, opts), { + onlySelf: true + })); + }); + this.updateValueAndValidity({ + onlySelf: true, + emitEvent: opts.emitEvent + }); + this._updateAncestors(__spreadProps(__spreadValues({}, opts), { + skipPristineCheck + }), this); + this._onDisabledChange.forEach((changeFn) => changeFn(false)); + } + _updateAncestors(opts, sourceControl) { + if (this._parent && !opts.onlySelf) { + this._parent.updateValueAndValidity(opts); + if (!opts.skipPristineCheck) { + this._parent._updatePristine({}, sourceControl); + } + this._parent._updateTouched({}, sourceControl); + } + } + /** + * Sets the parent of the control + * + * @param parent The new parent. + */ + setParent(parent) { + this._parent = parent; + } + /** + * The raw value of this control. For most control implementations, the raw value will include + * disabled children. + */ + getRawValue() { + return this.value; + } + updateValueAndValidity(opts = {}) { + this._setInitialStatus(); + this._updateValue(); + if (this.enabled) { + const shouldHaveEmitted = this._cancelExistingSubscription(); + this.errors = this._runValidator(); + this.status = this._calculateStatus(); + if (this.status === VALID || this.status === PENDING) { + this._runAsyncValidator(shouldHaveEmitted, opts.emitEvent); + } + } + const sourceControl = opts.sourceControl ?? this; + if (opts.emitEvent !== false) { + this._events.next(new ValueChangeEvent(this.value, sourceControl)); + this._events.next(new StatusChangeEvent(this.status, sourceControl)); + this.valueChanges.emit(this.value); + this.statusChanges.emit(this.status); + } + if (this._parent && !opts.onlySelf) { + this._parent.updateValueAndValidity(__spreadProps(__spreadValues({}, opts), { + sourceControl + })); + } + } + /** @internal */ + _updateTreeValidity(opts = { + emitEvent: true + }) { + this._forEachChild((ctrl) => ctrl._updateTreeValidity(opts)); + this.updateValueAndValidity({ + onlySelf: true, + emitEvent: opts.emitEvent + }); + } + _setInitialStatus() { + this.status = this._allControlsDisabled() ? DISABLED : VALID; + } + _runValidator() { + return this.validator ? this.validator(this) : null; + } + _runAsyncValidator(shouldHaveEmitted, emitEvent) { + if (this.asyncValidator) { + this.status = PENDING; + this._hasOwnPendingAsyncValidator = { + emitEvent: emitEvent !== false, + shouldHaveEmitted: shouldHaveEmitted !== false + }; + const obs = toObservable(this.asyncValidator(this)); + this._asyncValidationSubscription = obs.subscribe((errors) => { + this._hasOwnPendingAsyncValidator = null; + this.setErrors(errors, { + emitEvent, + shouldHaveEmitted + }); + }); + } + } + _cancelExistingSubscription() { + if (this._asyncValidationSubscription) { + this._asyncValidationSubscription.unsubscribe(); + const shouldHaveEmitted = (this._hasOwnPendingAsyncValidator?.emitEvent || this._hasOwnPendingAsyncValidator?.shouldHaveEmitted) ?? false; + this._hasOwnPendingAsyncValidator = null; + return shouldHaveEmitted; + } + return false; + } + setErrors(errors, opts = {}) { + this.errors = errors; + this._updateControlsErrors(opts.emitEvent !== false, this, opts.shouldHaveEmitted); + } + /** + * Retrieves a child control given the control's name or path. + * + * @param path A dot-delimited string or array of string/number values that define the path to the + * control. If a string is provided, passing it as a string literal will result in improved type + * information. Likewise, if an array is provided, passing it `as const` will cause improved type + * information to be available. + * + * @usageNotes + * ### Retrieve a nested control + * + * For example, to get a `name` control nested within a `person` sub-group: + * + * * `this.form.get('person.name');` + * + * -OR- + * + * * `this.form.get(['person', 'name'] as const);` // `as const` gives improved typings + * + * ### Retrieve a control in a FormArray + * + * When accessing an element inside a FormArray, you can use an element index. + * For example, to get a `price` control from the first element in an `items` array you can use: + * + * * `this.form.get('items.0.price');` + * + * -OR- + * + * * `this.form.get(['items', 0, 'price']);` + */ + get(path) { + let currPath = path; + if (currPath == null) return null; + if (!Array.isArray(currPath)) currPath = currPath.split("."); + if (currPath.length === 0) return null; + return currPath.reduce((control, name) => control && control._find(name), this); + } + /** + * @description + * Reports error data for the control with the given path. + * + * @param errorCode The code of the error to check + * @param path A list of control names that designates how to move from the current control + * to the control that should be queried for errors. + * + * @usageNotes + * For example, for the following `FormGroup`: + * + * ```ts + * form = new FormGroup({ + * address: new FormGroup({ street: new FormControl() }) + * }); + * ``` + * + * The path to the 'street' control from the root form would be 'address' -> 'street'. + * + * It can be provided to this method in one of two formats: + * + * 1. An array of string control names, e.g. `['address', 'street']` + * 1. A period-delimited list of control names in one string, e.g. `'address.street'` + * + * @returns error data for that particular error. If the control or error is not present, + * null is returned. + */ + getError(errorCode, path) { + const control = path ? this.get(path) : this; + return control && control.errors ? control.errors[errorCode] : null; + } + /** + * @description + * Reports whether the control with the given path has the error specified. + * + * @param errorCode The code of the error to check + * @param path A list of control names that designates how to move from the current control + * to the control that should be queried for errors. + * + * @usageNotes + * For example, for the following `FormGroup`: + * + * ```ts + * form = new FormGroup({ + * address: new FormGroup({ street: new FormControl() }) + * }); + * ``` + * + * The path to the 'street' control from the root form would be 'address' -> 'street'. + * + * It can be provided to this method in one of two formats: + * + * 1. An array of string control names, e.g. `['address', 'street']` + * 1. A period-delimited list of control names in one string, e.g. `'address.street'` + * + * If no path is given, this method checks for the error on the current control. + * + * @returns whether the given error is present in the control at the given path. + * + * If the control is not present, false is returned. + */ + hasError(errorCode, path) { + return !!this.getError(errorCode, path); + } + /** + * Retrieves the top-level ancestor of this control. + */ + get root() { + let x = this; + while (x._parent) { + x = x._parent; + } + return x; + } + /** @internal */ + _updateControlsErrors(emitEvent, changedControl, shouldHaveEmitted) { + this.status = this._calculateStatus(); + if (emitEvent) { + this.statusChanges.emit(this.status); + } + if (emitEvent || shouldHaveEmitted) { + this._events.next(new StatusChangeEvent(this.status, changedControl)); + } + if (this._parent) { + this._parent._updateControlsErrors(emitEvent, changedControl, shouldHaveEmitted); + } + } + /** @internal */ + _initObservables() { + this.valueChanges = new EventEmitter(); + this.statusChanges = new EventEmitter(); + } + _calculateStatus() { + if (this._allControlsDisabled()) return DISABLED; + if (this.errors) return INVALID; + if (this._hasOwnPendingAsyncValidator || this._anyControlsHaveStatus(PENDING)) return PENDING; + if (this._anyControlsHaveStatus(INVALID)) return INVALID; + return VALID; + } + /** @internal */ + _anyControlsHaveStatus(status) { + return this._anyControls((control) => control.status === status); + } + /** @internal */ + _anyControlsDirty() { + return this._anyControls((control) => control.dirty); + } + /** @internal */ + _anyControlsTouched() { + return this._anyControls((control) => control.touched); + } + /** @internal */ + _updatePristine(opts, changedControl) { + const newPristine = !this._anyControlsDirty(); + const changed = this.pristine !== newPristine; + this.pristine = newPristine; + if (this._parent && !opts.onlySelf) { + this._parent._updatePristine(opts, changedControl); + } + if (changed) { + this._events.next(new PristineChangeEvent(this.pristine, changedControl)); + } + } + /** @internal */ + _updateTouched(opts = {}, changedControl) { + this.touched = this._anyControlsTouched(); + this._events.next(new TouchedChangeEvent(this.touched, changedControl)); + if (this._parent && !opts.onlySelf) { + this._parent._updateTouched(opts, changedControl); + } + } + /** @internal */ + _onDisabledChange = []; + /** @internal */ + _registerOnCollectionChange(fn) { + this._onCollectionChange = fn; + } + /** @internal */ + _setUpdateStrategy(opts) { + if (isOptionsObj(opts) && opts.updateOn != null) { + this._updateOn = opts.updateOn; + } + } + /** + * Check to see if parent has been marked artificially dirty. + * + * @internal + */ + _parentMarkedDirty(onlySelf) { + const parentDirty = this._parent && this._parent.dirty; + return !onlySelf && !!parentDirty && !this._parent._anyControlsDirty(); + } + /** @internal */ + _find(name) { + return null; + } + /** + * Internal implementation of the `setValidators` method. Needs to be separated out into a + * different method, because it is called in the constructor and it can break cases where + * a control is extended. + */ + _assignValidators(validators) { + this._rawValidators = Array.isArray(validators) ? validators.slice() : validators; + this._composedValidatorFn = coerceToValidator(this._rawValidators); + } + /** + * Internal implementation of the `setAsyncValidators` method. Needs to be separated out into a + * different method, because it is called in the constructor and it can break cases where + * a control is extended. + */ + _assignAsyncValidators(validators) { + this._rawAsyncValidators = Array.isArray(validators) ? validators.slice() : validators; + this._composedAsyncValidatorFn = coerceToAsyncValidator(this._rawAsyncValidators); + } +}; +var FormGroup = class extends AbstractControl { + /** + * Creates a new `FormGroup` instance. + * + * @param controls A collection of child controls. The key for each child is the name + * under which it is registered. + * + * @param validatorOrOpts A synchronous validator function, or an array of + * such functions, or an `AbstractControlOptions` object that contains validation functions + * and a validation trigger. + * + * @param asyncValidator A single async validator or array of async validator functions + * + */ + constructor(controls, validatorOrOpts, asyncValidator) { + super(pickValidators(validatorOrOpts), pickAsyncValidators(asyncValidator, validatorOrOpts)); + (typeof ngDevMode === "undefined" || ngDevMode) && validateFormGroupControls(controls); + this.controls = controls; + this._initObservables(); + this._setUpdateStrategy(validatorOrOpts); + this._setUpControls(); + this.updateValueAndValidity({ + onlySelf: true, + // If `asyncValidator` is present, it will trigger control status change from `PENDING` to + // `VALID` or `INVALID`. The status should be broadcasted via the `statusChanges` observable, + // so we set `emitEvent` to `true` to allow that during the control creation process. + emitEvent: !!this.asyncValidator + }); + } + controls; + registerControl(name, control) { + if (this.controls[name]) return this.controls[name]; + this.controls[name] = control; + control.setParent(this); + control._registerOnCollectionChange(this._onCollectionChange); + return control; + } + addControl(name, control, options = {}) { + this.registerControl(name, control); + this.updateValueAndValidity({ + emitEvent: options.emitEvent + }); + this._onCollectionChange(); + } + /** + * Remove a control from this group. In a strongly-typed group, required controls cannot be + * removed. + * + * This method also updates the value and validity of the control. + * + * @param name The control name to remove from the collection + * @param options Specifies whether this FormGroup instance should emit events after a + * control is removed. + * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and + * `valueChanges` observables emit events with the latest status and value when the control is + * removed. When false, no events are emitted. + */ + removeControl(name, options = {}) { + if (this.controls[name]) this.controls[name]._registerOnCollectionChange(() => { + }); + delete this.controls[name]; + this.updateValueAndValidity({ + emitEvent: options.emitEvent + }); + this._onCollectionChange(); + } + setControl(name, control, options = {}) { + if (this.controls[name]) this.controls[name]._registerOnCollectionChange(() => { + }); + delete this.controls[name]; + if (control) this.registerControl(name, control); + this.updateValueAndValidity({ + emitEvent: options.emitEvent + }); + this._onCollectionChange(); + } + contains(controlName) { + return this.controls.hasOwnProperty(controlName) && this.controls[controlName].enabled; + } + /** + * Sets the value of the `FormGroup`. It accepts an object that matches + * the structure of the group, with control names as keys. + * + * @usageNotes + * ### Set the complete value for the form group + * + * ```ts + * const form = new FormGroup({ + * first: new FormControl(), + * last: new FormControl() + * }); + * + * console.log(form.value); // {first: null, last: null} + * + * form.setValue({first: 'Nancy', last: 'Drew'}); + * console.log(form.value); // {first: 'Nancy', last: 'Drew'} + * ``` + * + * @throws When strict checks fail, such as setting the value of a control + * that doesn't exist or if you exclude a value of a control that does exist. + * + * @param value The new value for the control that matches the structure of the group. + * @param options Configuration options that determine how the control propagates changes + * and emits events after the value changes. + * The configuration options are passed to the {@link AbstractControl#updateValueAndValidity + * updateValueAndValidity} method. + * + * * `onlySelf`: When true, each change only affects this control, and not its parent. Default is + * false. + * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and + * `valueChanges` + * observables emit events with the latest status and value when the control value is updated. + * When false, no events are emitted. + */ + setValue(value, options = {}) { + assertAllValuesPresent(this, true, value); + Object.keys(value).forEach((name) => { + assertControlPresent(this, true, name); + this.controls[name].setValue(value[name], { + onlySelf: true, + emitEvent: options.emitEvent + }); + }); + this.updateValueAndValidity(options); + } + /** + * Patches the value of the `FormGroup`. It accepts an object with control + * names as keys, and does its best to match the values to the correct controls + * in the group. + * + * It accepts both super-sets and sub-sets of the group without throwing an error. + * + * @usageNotes + * ### Patch the value for a form group + * + * ```ts + * const form = new FormGroup({ + * first: new FormControl(), + * last: new FormControl() + * }); + * console.log(form.value); // {first: null, last: null} + * + * form.patchValue({first: 'Nancy'}); + * console.log(form.value); // {first: 'Nancy', last: null} + * ``` + * + * @param value The object that matches the structure of the group. + * @param options Configuration options that determine how the control propagates changes and + * emits events after the value is patched. + * * `onlySelf`: When true, each change only affects this control and not its parent. Default is + * true. + * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and + * `valueChanges` observables emit events with the latest status and value when the control value + * is updated. When false, no events are emitted. The configuration options are passed to + * the {@link AbstractControl#updateValueAndValidity updateValueAndValidity} method. + */ + patchValue(value, options = {}) { + if (value == null) return; + Object.keys(value).forEach((name) => { + const control = this.controls[name]; + if (control) { + control.patchValue( + /* Guaranteed to be present, due to the outer forEach. */ + value[name], + { + onlySelf: true, + emitEvent: options.emitEvent + } + ); + } + }); + this.updateValueAndValidity(options); + } + /** + * Resets the `FormGroup`, marks all descendants `pristine` and `untouched` and sets + * the value of all descendants to their default values, or null if no defaults were provided. + * + * You reset to a specific form state by passing in a map of states + * that matches the structure of your form, with control names as keys. The state + * is a standalone value or a form state object with both a value and a disabled + * status. + * + * @param value Resets the control with an initial value, + * or an object that defines the initial value and disabled state. + * + * @param options Configuration options that determine how the control propagates changes + * and emits events when the group is reset. + * * `onlySelf`: When true, each change only affects this control, and not its parent. Default is + * false. + * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and + * `valueChanges` + * observables emit events with the latest status and value when the control is reset. + * When false, no events are emitted. + * The configuration options are passed to the {@link AbstractControl#updateValueAndValidity + * updateValueAndValidity} method. + * + * @usageNotes + * + * ### Reset the form group values + * + * ```ts + * const form = new FormGroup({ + * first: new FormControl('first name'), + * last: new FormControl('last name') + * }); + * + * console.log(form.value); // {first: 'first name', last: 'last name'} + * + * form.reset({ first: 'name', last: 'last name' }); + * + * console.log(form.value); // {first: 'name', last: 'last name'} + * ``` + * + * ### Reset the form group values and disabled status + * + * ```ts + * const form = new FormGroup({ + * first: new FormControl('first name'), + * last: new FormControl('last name') + * }); + * + * form.reset({ + * first: {value: 'name', disabled: true}, + * last: 'last' + * }); + * + * console.log(form.value); // {last: 'last'} + * console.log(form.get('first').status); // 'DISABLED' + * ``` + */ + reset(value = {}, options = {}) { + this._forEachChild((control, name) => { + control.reset(value ? value[name] : null, { + onlySelf: true, + emitEvent: options.emitEvent + }); + }); + this._updatePristine(options, this); + this._updateTouched(options, this); + this.updateValueAndValidity(options); + } + /** + * The aggregate value of the `FormGroup`, including any disabled controls. + * + * Retrieves all values regardless of disabled status. + */ + getRawValue() { + return this._reduceChildren({}, (acc, control, name) => { + acc[name] = control.getRawValue(); + return acc; + }); + } + /** @internal */ + _syncPendingControls() { + let subtreeUpdated = this._reduceChildren(false, (updated, child) => { + return child._syncPendingControls() ? true : updated; + }); + if (subtreeUpdated) this.updateValueAndValidity({ + onlySelf: true + }); + return subtreeUpdated; + } + /** @internal */ + _forEachChild(cb) { + Object.keys(this.controls).forEach((key) => { + const control = this.controls[key]; + control && cb(control, key); + }); + } + /** @internal */ + _setUpControls() { + this._forEachChild((control) => { + control.setParent(this); + control._registerOnCollectionChange(this._onCollectionChange); + }); + } + /** @internal */ + _updateValue() { + this.value = this._reduceValue(); + } + /** @internal */ + _anyControls(condition) { + for (const [controlName, control] of Object.entries(this.controls)) { + if (this.contains(controlName) && condition(control)) { + return true; + } + } + return false; + } + /** @internal */ + _reduceValue() { + let acc = {}; + return this._reduceChildren(acc, (acc2, control, name) => { + if (control.enabled || this.disabled) { + acc2[name] = control.value; + } + return acc2; + }); + } + /** @internal */ + _reduceChildren(initValue, fn) { + let res = initValue; + this._forEachChild((control, name) => { + res = fn(res, control, name); + }); + return res; + } + /** @internal */ + _allControlsDisabled() { + for (const controlName of Object.keys(this.controls)) { + if (this.controls[controlName].enabled) { + return false; + } + } + return Object.keys(this.controls).length > 0 || this.disabled; + } + /** @internal */ + _find(name) { + return this.controls.hasOwnProperty(name) ? this.controls[name] : null; + } +}; +function validateFormGroupControls(controls) { + const invalidKeys = Object.keys(controls).filter((key) => key.includes(".")); + if (invalidKeys.length > 0) { + console.warn(`FormGroup keys cannot include \`.\`, please replace the keys for: ${invalidKeys.join(",")}.`); + } +} +var UntypedFormGroup = FormGroup; +var isFormGroup = (control) => control instanceof FormGroup; +var FormRecord = class extends FormGroup { +}; +var isFormRecord = (control) => control instanceof FormRecord; +var CALL_SET_DISABLED_STATE = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "CallSetDisabledState" : "", { + providedIn: "root", + factory: () => setDisabledStateDefault +}); +var setDisabledStateDefault = "always"; +function controlPath(name, parent) { + return [...parent.path, name]; +} +function setUpControl(control, dir, callSetDisabledState = setDisabledStateDefault) { + if (typeof ngDevMode === "undefined" || ngDevMode) { + if (!control) _throwError(dir, "Cannot find control with"); + if (!dir.valueAccessor) _throwMissingValueAccessorError(dir); + } + setUpValidators(control, dir); + dir.valueAccessor.writeValue(control.value); + if (control.disabled || callSetDisabledState === "always") { + dir.valueAccessor.setDisabledState?.(control.disabled); + } + setUpViewChangePipeline(control, dir); + setUpModelChangePipeline(control, dir); + setUpBlurPipeline(control, dir); + setUpDisabledChangeHandler(control, dir); +} +function cleanUpControl(control, dir, validateControlPresenceOnChange = true) { + const noop = () => { + if (validateControlPresenceOnChange && (typeof ngDevMode === "undefined" || ngDevMode)) { + _noControlError(dir); + } + }; + if (dir.valueAccessor) { + dir.valueAccessor.registerOnChange(noop); + dir.valueAccessor.registerOnTouched(noop); + } + cleanUpValidators(control, dir); + if (control) { + dir._invokeOnDestroyCallbacks(); + control._registerOnCollectionChange(() => { + }); + } +} +function registerOnValidatorChange(validators, onChange) { + validators.forEach((validator) => { + if (validator.registerOnValidatorChange) validator.registerOnValidatorChange(onChange); + }); +} +function setUpDisabledChangeHandler(control, dir) { + if (dir.valueAccessor.setDisabledState) { + const onDisabledChange = (isDisabled) => { + dir.valueAccessor.setDisabledState(isDisabled); + }; + control.registerOnDisabledChange(onDisabledChange); + dir._registerOnDestroy(() => { + control._unregisterOnDisabledChange(onDisabledChange); + }); + } +} +function setUpValidators(control, dir) { + const validators = getControlValidators(control); + if (dir.validator !== null) { + control.setValidators(mergeValidators(validators, dir.validator)); + } else if (typeof validators === "function") { + control.setValidators([validators]); + } + const asyncValidators = getControlAsyncValidators(control); + if (dir.asyncValidator !== null) { + control.setAsyncValidators(mergeValidators(asyncValidators, dir.asyncValidator)); + } else if (typeof asyncValidators === "function") { + control.setAsyncValidators([asyncValidators]); + } + const onValidatorChange = () => control.updateValueAndValidity(); + registerOnValidatorChange(dir._rawValidators, onValidatorChange); + registerOnValidatorChange(dir._rawAsyncValidators, onValidatorChange); +} +function cleanUpValidators(control, dir) { + let isControlUpdated = false; + if (control !== null) { + if (dir.validator !== null) { + const validators = getControlValidators(control); + if (Array.isArray(validators) && validators.length > 0) { + const updatedValidators = validators.filter((validator) => validator !== dir.validator); + if (updatedValidators.length !== validators.length) { + isControlUpdated = true; + control.setValidators(updatedValidators); + } + } + } + if (dir.asyncValidator !== null) { + const asyncValidators = getControlAsyncValidators(control); + if (Array.isArray(asyncValidators) && asyncValidators.length > 0) { + const updatedAsyncValidators = asyncValidators.filter((asyncValidator) => asyncValidator !== dir.asyncValidator); + if (updatedAsyncValidators.length !== asyncValidators.length) { + isControlUpdated = true; + control.setAsyncValidators(updatedAsyncValidators); + } + } + } + } + const noop = () => { + }; + registerOnValidatorChange(dir._rawValidators, noop); + registerOnValidatorChange(dir._rawAsyncValidators, noop); + return isControlUpdated; +} +function setUpViewChangePipeline(control, dir) { + dir.valueAccessor.registerOnChange((newValue) => { + control._pendingValue = newValue; + control._pendingChange = true; + control._pendingDirty = true; + if (control.updateOn === "change") updateControl(control, dir); + }); +} +function setUpBlurPipeline(control, dir) { + dir.valueAccessor.registerOnTouched(() => { + control._pendingTouched = true; + if (control.updateOn === "blur" && control._pendingChange) updateControl(control, dir); + if (control.updateOn !== "submit") control.markAsTouched(); + }); +} +function updateControl(control, dir) { + if (control._pendingDirty) control.markAsDirty(); + control.setValue(control._pendingValue, { + emitModelToViewChange: false + }); + dir.viewToModelUpdate(control._pendingValue); + control._pendingChange = false; +} +function setUpModelChangePipeline(control, dir) { + const onChange = (newValue, emitModelEvent) => { + dir.valueAccessor.writeValue(newValue); + if (emitModelEvent) dir.viewToModelUpdate(newValue); + }; + control.registerOnChange(onChange); + dir._registerOnDestroy(() => { + control._unregisterOnChange(onChange); + }); +} +function setUpFormContainer(control, dir) { + if (control == null && (typeof ngDevMode === "undefined" || ngDevMode)) _throwError(dir, "Cannot find control with"); + setUpValidators(control, dir); +} +function cleanUpFormContainer(control, dir) { + return cleanUpValidators(control, dir); +} +function _noControlError(dir) { + return _throwError(dir, "There is no FormControl instance attached to form control element with"); +} +function _throwError(dir, message) { + const messageEnd = _describeControlLocation(dir); + throw new Error(`${message} ${messageEnd}`); +} +function _describeControlLocation(dir) { + const path = dir.path; + if (path && path.length > 1) return `path: '${path.join(" -> ")}'`; + if (path?.[0]) return `name: '${path}'`; + return "unspecified name attribute"; +} +function _throwMissingValueAccessorError(dir) { + const loc = _describeControlLocation(dir); + throw new RuntimeError(-1203, `No value accessor for form control ${loc}.`); +} +function _throwInvalidValueAccessorError(dir) { + const loc = _describeControlLocation(dir); + throw new RuntimeError(1200, `Value accessor was not provided as an array for form control with ${loc}. Check that the \`NG_VALUE_ACCESSOR\` token is configured as a \`multi: true\` provider.`); +} +function isPropertyUpdated(changes, viewModel) { + if (!changes.hasOwnProperty("model")) return false; + const change = changes["model"]; + if (change.isFirstChange()) return true; + return !Object.is(viewModel, change.currentValue); +} +function isBuiltInAccessor(valueAccessor) { + return Object.getPrototypeOf(valueAccessor.constructor) === BuiltInControlValueAccessor; +} +function syncPendingControls(form, directives) { + form._syncPendingControls(); + directives.forEach((dir) => { + const control = dir.control; + if (control.updateOn === "submit" && control._pendingChange) { + dir.viewToModelUpdate(control._pendingValue); + control._pendingChange = false; + } + }); +} +function selectValueAccessor(dir, valueAccessors) { + if (!valueAccessors) return null; + if (!Array.isArray(valueAccessors) && (typeof ngDevMode === "undefined" || ngDevMode)) _throwInvalidValueAccessorError(dir); + let defaultAccessor = void 0; + let builtinAccessor = void 0; + let customAccessor = void 0; + valueAccessors.forEach((v) => { + if (v.constructor === DefaultValueAccessor) { + defaultAccessor = v; + } else if (isBuiltInAccessor(v)) { + if (builtinAccessor && (typeof ngDevMode === "undefined" || ngDevMode)) _throwError(dir, "More than one built-in value accessor matches form control with"); + builtinAccessor = v; + } else { + if (customAccessor && (typeof ngDevMode === "undefined" || ngDevMode)) _throwError(dir, "More than one custom value accessor matches form control with"); + customAccessor = v; + } + }); + if (customAccessor) return customAccessor; + if (builtinAccessor) return builtinAccessor; + if (defaultAccessor) return defaultAccessor; + if (typeof ngDevMode === "undefined" || ngDevMode) { + _throwError(dir, "No valid value accessor for form control with"); + } + return null; +} +function removeListItem$1(list, el) { + const index = list.indexOf(el); + if (index > -1) list.splice(index, 1); +} +function _ngModelWarning(name, type, instance, warningConfig) { + if (warningConfig === "never") return; + if ((warningConfig === null || warningConfig === "once") && !type._ngModelWarningSentOnce || warningConfig === "always" && !instance._ngModelWarningSent) { + console.warn(ngModelWarning(name)); + type._ngModelWarningSentOnce = true; + instance._ngModelWarningSent = true; + } +} +var formDirectiveProvider$1 = { + provide: ControlContainer, + useExisting: forwardRef(() => NgForm) +}; +var resolvedPromise$1 = (() => Promise.resolve())(); +var NgForm = class _NgForm extends ControlContainer { + callSetDisabledState; + /** + * @description + * Returns whether the form submission has been triggered. + */ + get submitted() { + return untracked(this.submittedReactive); + } + /** @internal */ + _submitted = computed(() => this.submittedReactive(), ...ngDevMode ? [{ + debugName: "_submitted" + }] : []); + submittedReactive = signal(false, ...ngDevMode ? [{ + debugName: "submittedReactive" + }] : []); + _directives = /* @__PURE__ */ new Set(); + /** + * @description + * The `FormGroup` instance created for this form. + */ + form; + /** + * @description + * Event emitter for the "ngSubmit" event + */ + ngSubmit = new EventEmitter(); + /** + * @description + * Tracks options for the `NgForm` instance. + * + * **updateOn**: Sets the default `updateOn` value for all child `NgModels` below it + * unless explicitly set by a child `NgModel` using `ngModelOptions`). Defaults to 'change'. + * Possible values: `'change'` | `'blur'` | `'submit'`. + * + */ + options; + constructor(validators, asyncValidators, callSetDisabledState) { + super(); + this.callSetDisabledState = callSetDisabledState; + this.form = new FormGroup({}, composeValidators(validators), composeAsyncValidators(asyncValidators)); + } + /** @docs-private */ + ngAfterViewInit() { + this._setUpdateStrategy(); + } + /** + * @description + * The directive instance. + */ + get formDirective() { + return this; + } + /** + * @description + * The internal `FormGroup` instance. + */ + get control() { + return this.form; + } + /** + * @description + * Returns an array representing the path to this group. Because this directive + * always lives at the top level of a form, it is always an empty array. + */ + get path() { + return []; + } + /** + * @description + * Returns a map of the controls in this group. + */ + get controls() { + return this.form.controls; + } + /** + * @description + * Method that sets up the control directive in this group, re-calculates its value + * and validity, and adds the instance to the internal list of directives. + * + * @param dir The `NgModel` directive instance. + */ + addControl(dir) { + resolvedPromise$1.then(() => { + const container = this._findContainer(dir.path); + dir.control = container.registerControl(dir.name, dir.control); + setUpControl(dir.control, dir, this.callSetDisabledState); + dir.control.updateValueAndValidity({ + emitEvent: false + }); + this._directives.add(dir); + }); + } + /** + * @description + * Retrieves the `FormControl` instance from the provided `NgModel` directive. + * + * @param dir The `NgModel` directive instance. + */ + getControl(dir) { + return this.form.get(dir.path); + } + /** + * @description + * Removes the `NgModel` instance from the internal list of directives + * + * @param dir The `NgModel` directive instance. + */ + removeControl(dir) { + resolvedPromise$1.then(() => { + const container = this._findContainer(dir.path); + if (container) { + container.removeControl(dir.name); + } + this._directives.delete(dir); + }); + } + /** + * @description + * Adds a new `NgModelGroup` directive instance to the form. + * + * @param dir The `NgModelGroup` directive instance. + */ + addFormGroup(dir) { + resolvedPromise$1.then(() => { + const container = this._findContainer(dir.path); + const group = new FormGroup({}); + setUpFormContainer(group, dir); + container.registerControl(dir.name, group); + group.updateValueAndValidity({ + emitEvent: false + }); + }); + } + /** + * @description + * Removes the `NgModelGroup` directive instance from the form. + * + * @param dir The `NgModelGroup` directive instance. + */ + removeFormGroup(dir) { + resolvedPromise$1.then(() => { + const container = this._findContainer(dir.path); + if (container) { + container.removeControl(dir.name); + } + }); + } + /** + * @description + * Retrieves the `FormGroup` for a provided `NgModelGroup` directive instance + * + * @param dir The `NgModelGroup` directive instance. + */ + getFormGroup(dir) { + return this.form.get(dir.path); + } + /** + * Sets the new value for the provided `NgControl` directive. + * + * @param dir The `NgControl` directive instance. + * @param value The new value for the directive's control. + */ + updateModel(dir, value) { + resolvedPromise$1.then(() => { + const ctrl = this.form.get(dir.path); + ctrl.setValue(value); + }); + } + /** + * @description + * Sets the value for this `FormGroup`. + * + * @param value The new value + */ + setValue(value) { + this.control.setValue(value); + } + /** + * @description + * Method called when the "submit" event is triggered on the form. + * Triggers the `ngSubmit` emitter to emit the "submit" event as its payload. + * + * @param $event The "submit" event object + */ + onSubmit($event) { + this.submittedReactive.set(true); + syncPendingControls(this.form, this._directives); + this.ngSubmit.emit($event); + this.form._events.next(new FormSubmittedEvent(this.control)); + return $event?.target?.method === "dialog"; + } + /** + * @description + * Method called when the "reset" event is triggered on the form. + */ + onReset() { + this.resetForm(); + } + /** + * @description + * Resets the form to an initial value and resets its submitted status. + * + * @param value The new value for the form. + */ + resetForm(value = void 0) { + this.form.reset(value); + this.submittedReactive.set(false); + this.form._events.next(new FormResetEvent(this.form)); + } + _setUpdateStrategy() { + if (this.options && this.options.updateOn != null) { + this.form._updateOn = this.options.updateOn; + } + } + _findContainer(path) { + path.pop(); + return path.length ? this.form.get(path) : this.form; + } + static ɵfac = function NgForm_Factory(__ngFactoryType__) { + return new (__ngFactoryType__ || _NgForm)(ɵɵdirectiveInject(NG_VALIDATORS, 10), ɵɵdirectiveInject(NG_ASYNC_VALIDATORS, 10), ɵɵdirectiveInject(CALL_SET_DISABLED_STATE, 8)); + }; + static ɵdir = ɵɵdefineDirective({ + type: _NgForm, + selectors: [["form", 3, "ngNoForm", "", 3, "formGroup", ""], ["ng-form"], ["", "ngForm", ""]], + hostBindings: function NgForm_HostBindings(rf, ctx) { + if (rf & 1) { + ɵɵlistener("submit", function NgForm_submit_HostBindingHandler($event) { + return ctx.onSubmit($event); + })("reset", function NgForm_reset_HostBindingHandler() { + return ctx.onReset(); + }); + } + }, + inputs: { + options: [0, "ngFormOptions", "options"] + }, + outputs: { + ngSubmit: "ngSubmit" + }, + exportAs: ["ngForm"], + standalone: false, + features: [ɵɵProvidersFeature([formDirectiveProvider$1]), ɵɵInheritDefinitionFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgForm, [{ + type: Directive, + args: [{ + selector: "form:not([ngNoForm]):not([formGroup]),ng-form,[ngForm]", + providers: [formDirectiveProvider$1], + host: { + "(submit)": "onSubmit($event)", + "(reset)": "onReset()" + }, + outputs: ["ngSubmit"], + exportAs: "ngForm", + standalone: false + }] + }], () => [{ + type: void 0, + decorators: [{ + type: Optional + }, { + type: Self + }, { + type: Inject, + args: [NG_VALIDATORS] + }] + }, { + type: void 0, + decorators: [{ + type: Optional + }, { + type: Self + }, { + type: Inject, + args: [NG_ASYNC_VALIDATORS] + }] + }, { + type: void 0, + decorators: [{ + type: Optional + }, { + type: Inject, + args: [CALL_SET_DISABLED_STATE] + }] + }], { + options: [{ + type: Input, + args: ["ngFormOptions"] + }] + }); +})(); +function removeListItem(list, el) { + const index = list.indexOf(el); + if (index > -1) list.splice(index, 1); +} +function isFormControlState(formState) { + return typeof formState === "object" && formState !== null && Object.keys(formState).length === 2 && "value" in formState && "disabled" in formState; +} +var FormControl = class FormControl2 extends AbstractControl { + /** @publicApi */ + defaultValue = null; + /** @internal */ + _onChange = []; + /** @internal */ + _pendingValue; + /** @internal */ + _pendingChange = false; + constructor(formState = null, validatorOrOpts, asyncValidator) { + super(pickValidators(validatorOrOpts), pickAsyncValidators(asyncValidator, validatorOrOpts)); + this._applyFormState(formState); + this._setUpdateStrategy(validatorOrOpts); + this._initObservables(); + this.updateValueAndValidity({ + onlySelf: true, + // If `asyncValidator` is present, it will trigger control status change from `PENDING` to + // `VALID` or `INVALID`. + // The status should be broadcasted via the `statusChanges` observable, so we set + // `emitEvent` to `true` to allow that during the control creation process. + emitEvent: !!this.asyncValidator + }); + if (isOptionsObj(validatorOrOpts) && (validatorOrOpts.nonNullable || validatorOrOpts.initialValueIsDefault)) { + if (isFormControlState(formState)) { + this.defaultValue = formState.value; + } else { + this.defaultValue = formState; + } + } + } + setValue(value, options = {}) { + this.value = this._pendingValue = value; + if (this._onChange.length && options.emitModelToViewChange !== false) { + this._onChange.forEach((changeFn) => changeFn(this.value, options.emitViewToModelChange !== false)); + } + this.updateValueAndValidity(options); + } + patchValue(value, options = {}) { + this.setValue(value, options); + } + reset(formState = this.defaultValue, options = {}) { + this._applyFormState(formState); + this.markAsPristine(options); + this.markAsUntouched(options); + this.setValue(this.value, options); + this._pendingChange = false; + } + /** @internal */ + _updateValue() { + } + /** @internal */ + _anyControls(condition) { + return false; + } + /** @internal */ + _allControlsDisabled() { + return this.disabled; + } + registerOnChange(fn) { + this._onChange.push(fn); + } + /** @internal */ + _unregisterOnChange(fn) { + removeListItem(this._onChange, fn); + } + registerOnDisabledChange(fn) { + this._onDisabledChange.push(fn); + } + /** @internal */ + _unregisterOnDisabledChange(fn) { + removeListItem(this._onDisabledChange, fn); + } + /** @internal */ + _forEachChild(cb) { + } + /** @internal */ + _syncPendingControls() { + if (this.updateOn === "submit") { + if (this._pendingDirty) this.markAsDirty(); + if (this._pendingTouched) this.markAsTouched(); + if (this._pendingChange) { + this.setValue(this._pendingValue, { + onlySelf: true, + emitModelToViewChange: false + }); + return true; + } + } + return false; + } + _applyFormState(formState) { + if (isFormControlState(formState)) { + this.value = this._pendingValue = formState.value; + formState.disabled ? this.disable({ + onlySelf: true, + emitEvent: false + }) : this.enable({ + onlySelf: true, + emitEvent: false + }); + } else { + this.value = this._pendingValue = formState; + } + } +}; +var UntypedFormControl = FormControl; +var isFormControl = (control) => control instanceof FormControl; +var AbstractFormGroupDirective = class _AbstractFormGroupDirective extends ControlContainer { + /** + * @description + * The parent control for the group + * + * @internal + */ + _parent; + /** @docs-private */ + ngOnInit() { + this._checkParentType(); + this.formDirective.addFormGroup(this); + } + /** @docs-private */ + ngOnDestroy() { + if (this.formDirective) { + this.formDirective.removeFormGroup(this); + } + } + /** + * @description + * The `FormGroup` bound to this directive. + */ + get control() { + return this.formDirective.getFormGroup(this); + } + /** + * @description + * The path to this group from the top-level directive. + */ + get path() { + return controlPath(this.name == null ? this.name : this.name.toString(), this._parent); + } + /** + * @description + * The top-level directive for this group if present, otherwise null. + */ + get formDirective() { + return this._parent ? this._parent.formDirective : null; + } + /** @internal */ + _checkParentType() { + } + static ɵfac = /* @__PURE__ */ (() => { + let ɵAbstractFormGroupDirective_BaseFactory; + return function AbstractFormGroupDirective_Factory(__ngFactoryType__) { + return (ɵAbstractFormGroupDirective_BaseFactory || (ɵAbstractFormGroupDirective_BaseFactory = ɵɵgetInheritedFactory(_AbstractFormGroupDirective)))(__ngFactoryType__ || _AbstractFormGroupDirective); + }; + })(); + static ɵdir = ɵɵdefineDirective({ + type: _AbstractFormGroupDirective, + standalone: false, + features: [ɵɵInheritDefinitionFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(AbstractFormGroupDirective, [{ + type: Directive, + args: [{ + standalone: false + }] + }], null, null); +})(); +function modelParentException() { + return new RuntimeError(1350, ` + ngModel cannot be used to register form controls with a parent formGroup directive. Try using + formGroup's partner directive "formControlName" instead. Example: + + ${formControlNameExample} + + Or, if you'd like to avoid registering this form control, indicate that it's standalone in ngModelOptions: + + Example: + + ${ngModelWithFormGroupExample}`); +} +function formGroupNameException() { + return new RuntimeError(1351, ` + ngModel cannot be used to register form controls with a parent formGroupName or formArrayName directive. + + Option 1: Use formControlName instead of ngModel (reactive strategy): + + ${formGroupNameExample} + + Option 2: Update ngModel's parent be ngModelGroup (template-driven strategy): + + ${ngModelGroupExample}`); +} +function missingNameException() { + return new RuntimeError(1352, `If ngModel is used within a form tag, either the name attribute must be set or the form + control must be defined as 'standalone' in ngModelOptions. + + Example 1: + Example 2: `); +} +function modelGroupParentException() { + return new RuntimeError(1353, ` + ngModelGroup cannot be used with a parent formGroup directive. + + Option 1: Use formGroupName instead of ngModelGroup (reactive strategy): + + ${formGroupNameExample} + + Option 2: Use a regular form tag instead of the formGroup directive (template-driven strategy): + + ${ngModelGroupExample}`); +} +var modelGroupProvider = { + provide: ControlContainer, + useExisting: forwardRef(() => NgModelGroup) +}; +var NgModelGroup = class _NgModelGroup extends AbstractFormGroupDirective { + /** + * @description + * Tracks the name of the `NgModelGroup` bound to the directive. The name corresponds + * to a key in the parent `NgForm`. + */ + name = ""; + constructor(parent, validators, asyncValidators) { + super(); + this._parent = parent; + this._setValidators(validators); + this._setAsyncValidators(asyncValidators); + } + /** @internal */ + _checkParentType() { + if (!(this._parent instanceof _NgModelGroup) && !(this._parent instanceof NgForm) && (typeof ngDevMode === "undefined" || ngDevMode)) { + throw modelGroupParentException(); + } + } + static ɵfac = function NgModelGroup_Factory(__ngFactoryType__) { + return new (__ngFactoryType__ || _NgModelGroup)(ɵɵdirectiveInject(ControlContainer, 5), ɵɵdirectiveInject(NG_VALIDATORS, 10), ɵɵdirectiveInject(NG_ASYNC_VALIDATORS, 10)); + }; + static ɵdir = ɵɵdefineDirective({ + type: _NgModelGroup, + selectors: [["", "ngModelGroup", ""]], + inputs: { + name: [0, "ngModelGroup", "name"] + }, + exportAs: ["ngModelGroup"], + standalone: false, + features: [ɵɵProvidersFeature([modelGroupProvider]), ɵɵInheritDefinitionFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgModelGroup, [{ + type: Directive, + args: [{ + selector: "[ngModelGroup]", + providers: [modelGroupProvider], + exportAs: "ngModelGroup", + standalone: false + }] + }], () => [{ + type: ControlContainer, + decorators: [{ + type: Host + }, { + type: SkipSelf + }] + }, { + type: void 0, + decorators: [{ + type: Optional + }, { + type: Self + }, { + type: Inject, + args: [NG_VALIDATORS] + }] + }, { + type: void 0, + decorators: [{ + type: Optional + }, { + type: Self + }, { + type: Inject, + args: [NG_ASYNC_VALIDATORS] + }] + }], { + name: [{ + type: Input, + args: ["ngModelGroup"] + }] + }); +})(); +var formControlBinding$1 = { + provide: NgControl, + useExisting: forwardRef(() => NgModel) +}; +var resolvedPromise = (() => Promise.resolve())(); +var NgModel = class _NgModel extends NgControl { + _changeDetectorRef; + callSetDisabledState; + control = new FormControl(); + // At runtime we coerce arbitrary values assigned to the "disabled" input to a "boolean". + // This is not reflected in the type of the property because outside of templates, consumers + // should only deal with booleans. In templates, a string is allowed for convenience and to + // match the native "disabled attribute" semantics which can be observed on input elements. + // This static member tells the compiler that values of type "string" can also be assigned + // to the input in a template. + /** @docs-private */ + static ngAcceptInputType_isDisabled; + /** @internal */ + _registered = false; + /** + * Internal reference to the view model value. + * @docs-private + */ + viewModel; + /** + * @description + * Tracks the name bound to the directive. If a parent form exists, it + * uses this name as a key to retrieve this control's value. + */ + name = ""; + /** + * @description + * Tracks whether the control is disabled. + */ + isDisabled; + /** + * @description + * Tracks the value bound to this directive. + */ + model; + /** + * @description + * Tracks the configuration options for this `ngModel` instance. + * + * **name**: An alternative to setting the name attribute on the form control element. See + * the [example](api/forms/NgModel#using-ngmodel-on-a-standalone-control) for using `NgModel` + * as a standalone control. + * + * **standalone**: When set to true, the `ngModel` will not register itself with its parent form, + * and acts as if it's not in the form. Defaults to false. If no parent form exists, this option + * has no effect. + * + * **updateOn**: Defines the event upon which the form control value and validity update. + * Defaults to 'change'. Possible values: `'change'` | `'blur'` | `'submit'`. + * + */ + options; + /** + * @description + * Event emitter for producing the `ngModelChange` event after + * the view model updates. + */ + update = new EventEmitter(); + constructor(parent, validators, asyncValidators, valueAccessors, _changeDetectorRef, callSetDisabledState) { + super(); + this._changeDetectorRef = _changeDetectorRef; + this.callSetDisabledState = callSetDisabledState; + this._parent = parent; + this._setValidators(validators); + this._setAsyncValidators(asyncValidators); + this.valueAccessor = selectValueAccessor(this, valueAccessors); + } + /** @docs-private */ + ngOnChanges(changes) { + this._checkForErrors(); + if (!this._registered || "name" in changes) { + if (this._registered) { + this._checkName(); + if (this.formDirective) { + const oldName = changes["name"].previousValue; + this.formDirective.removeControl({ + name: oldName, + path: this._getPath(oldName) + }); + } + } + this._setUpControl(); + } + if ("isDisabled" in changes) { + this._updateDisabled(changes); + } + if (isPropertyUpdated(changes, this.viewModel)) { + this._updateValue(this.model); + this.viewModel = this.model; + } + } + /** @docs-private */ + ngOnDestroy() { + this.formDirective && this.formDirective.removeControl(this); + } + /** + * @description + * Returns an array that represents the path from the top-level form to this control. + * Each index is the string name of the control on that level. + */ + get path() { + return this._getPath(this.name); + } + /** + * @description + * The top-level directive for this control if present, otherwise null. + */ + get formDirective() { + return this._parent ? this._parent.formDirective : null; + } + /** + * @description + * Sets the new value for the view model and emits an `ngModelChange` event. + * + * @param newValue The new value emitted by `ngModelChange`. + */ + viewToModelUpdate(newValue) { + this.viewModel = newValue; + this.update.emit(newValue); + } + _setUpControl() { + this._setUpdateStrategy(); + this._isStandalone() ? this._setUpStandalone() : this.formDirective.addControl(this); + this._registered = true; + } + _setUpdateStrategy() { + if (this.options && this.options.updateOn != null) { + this.control._updateOn = this.options.updateOn; + } + } + _isStandalone() { + return !this._parent || !!(this.options && this.options.standalone); + } + _setUpStandalone() { + setUpControl(this.control, this, this.callSetDisabledState); + this.control.updateValueAndValidity({ + emitEvent: false + }); + } + _checkForErrors() { + if ((typeof ngDevMode === "undefined" || ngDevMode) && !this._isStandalone()) { + checkParentType$1(this._parent); + } + this._checkName(); + } + _checkName() { + if (this.options && this.options.name) this.name = this.options.name; + if (!this._isStandalone() && !this.name && (typeof ngDevMode === "undefined" || ngDevMode)) { + throw missingNameException(); + } + } + _updateValue(value) { + resolvedPromise.then(() => { + this.control.setValue(value, { + emitViewToModelChange: false + }); + this._changeDetectorRef?.markForCheck(); + }); + } + _updateDisabled(changes) { + const disabledValue = changes["isDisabled"].currentValue; + const isDisabled = disabledValue !== 0 && booleanAttribute(disabledValue); + resolvedPromise.then(() => { + if (isDisabled && !this.control.disabled) { + this.control.disable(); + } else if (!isDisabled && this.control.disabled) { + this.control.enable(); + } + this._changeDetectorRef?.markForCheck(); + }); + } + _getPath(controlName) { + return this._parent ? controlPath(controlName, this._parent) : [controlName]; + } + static ɵfac = function NgModel_Factory(__ngFactoryType__) { + return new (__ngFactoryType__ || _NgModel)(ɵɵdirectiveInject(ControlContainer, 9), ɵɵdirectiveInject(NG_VALIDATORS, 10), ɵɵdirectiveInject(NG_ASYNC_VALIDATORS, 10), ɵɵdirectiveInject(NG_VALUE_ACCESSOR, 10), ɵɵdirectiveInject(ChangeDetectorRef, 8), ɵɵdirectiveInject(CALL_SET_DISABLED_STATE, 8)); + }; + static ɵdir = ɵɵdefineDirective({ + type: _NgModel, + selectors: [["", "ngModel", "", 3, "formControlName", "", 3, "formControl", ""]], + inputs: { + name: "name", + isDisabled: [0, "disabled", "isDisabled"], + model: [0, "ngModel", "model"], + options: [0, "ngModelOptions", "options"] + }, + outputs: { + update: "ngModelChange" + }, + exportAs: ["ngModel"], + standalone: false, + features: [ɵɵProvidersFeature([formControlBinding$1]), ɵɵInheritDefinitionFeature, ɵɵNgOnChangesFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgModel, [{ + type: Directive, + args: [{ + selector: "[ngModel]:not([formControlName]):not([formControl])", + providers: [formControlBinding$1], + exportAs: "ngModel", + standalone: false + }] + }], () => [{ + type: ControlContainer, + decorators: [{ + type: Optional + }, { + type: Host + }] + }, { + type: void 0, + decorators: [{ + type: Optional + }, { + type: Self + }, { + type: Inject, + args: [NG_VALIDATORS] + }] + }, { + type: void 0, + decorators: [{ + type: Optional + }, { + type: Self + }, { + type: Inject, + args: [NG_ASYNC_VALIDATORS] + }] + }, { + type: void 0, + decorators: [{ + type: Optional + }, { + type: Self + }, { + type: Inject, + args: [NG_VALUE_ACCESSOR] + }] + }, { + type: ChangeDetectorRef, + decorators: [{ + type: Optional + }, { + type: Inject, + args: [ChangeDetectorRef] + }] + }, { + type: void 0, + decorators: [{ + type: Optional + }, { + type: Inject, + args: [CALL_SET_DISABLED_STATE] + }] + }], { + name: [{ + type: Input + }], + isDisabled: [{ + type: Input, + args: ["disabled"] + }], + model: [{ + type: Input, + args: ["ngModel"] + }], + options: [{ + type: Input, + args: ["ngModelOptions"] + }], + update: [{ + type: Output, + args: ["ngModelChange"] + }] + }); +})(); +function checkParentType$1(parent) { + if (!(parent instanceof NgModelGroup) && parent instanceof AbstractFormGroupDirective) { + throw formGroupNameException(); + } else if (!(parent instanceof NgModelGroup) && !(parent instanceof NgForm)) { + throw modelParentException(); + } +} +var ɵNgNoValidate = class _ɵNgNoValidate { + static ɵfac = function ɵNgNoValidate_Factory(__ngFactoryType__) { + return new (__ngFactoryType__ || _ɵNgNoValidate)(); + }; + static ɵdir = ɵɵdefineDirective({ + type: _ɵNgNoValidate, + selectors: [["form", 3, "ngNoForm", "", 3, "ngNativeValidate", ""]], + hostAttrs: ["novalidate", ""], + standalone: false + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ɵNgNoValidate, [{ + type: Directive, + args: [{ + selector: "form:not([ngNoForm]):not([ngNativeValidate])", + host: { + "novalidate": "" + }, + standalone: false + }] + }], null, null); +})(); +var NUMBER_VALUE_ACCESSOR = { + provide: NG_VALUE_ACCESSOR, + useExisting: forwardRef(() => NumberValueAccessor), + multi: true +}; +var NumberValueAccessor = class _NumberValueAccessor extends BuiltInControlValueAccessor { + /** + * Sets the "value" property on the input element. + * @docs-private + */ + writeValue(value) { + const normalizedValue = value == null ? "" : value; + this.setProperty("value", normalizedValue); + } + /** + * Registers a function called when the control value changes. + * @docs-private + */ + registerOnChange(fn) { + this.onChange = (value) => { + fn(value == "" ? null : parseFloat(value)); + }; + } + static ɵfac = /* @__PURE__ */ (() => { + let ɵNumberValueAccessor_BaseFactory; + return function NumberValueAccessor_Factory(__ngFactoryType__) { + return (ɵNumberValueAccessor_BaseFactory || (ɵNumberValueAccessor_BaseFactory = ɵɵgetInheritedFactory(_NumberValueAccessor)))(__ngFactoryType__ || _NumberValueAccessor); + }; + })(); + static ɵdir = ɵɵdefineDirective({ + type: _NumberValueAccessor, + selectors: [["input", "type", "number", "formControlName", ""], ["input", "type", "number", "formControl", ""], ["input", "type", "number", "ngModel", ""]], + hostBindings: function NumberValueAccessor_HostBindings(rf, ctx) { + if (rf & 1) { + ɵɵlistener("input", function NumberValueAccessor_input_HostBindingHandler($event) { + return ctx.onChange($event.target.value); + })("blur", function NumberValueAccessor_blur_HostBindingHandler() { + return ctx.onTouched(); + }); + } + }, + standalone: false, + features: [ɵɵProvidersFeature([NUMBER_VALUE_ACCESSOR]), ɵɵInheritDefinitionFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NumberValueAccessor, [{ + type: Directive, + args: [{ + selector: "input[type=number][formControlName],input[type=number][formControl],input[type=number][ngModel]", + host: { + "(input)": "onChange($any($event.target).value)", + "(blur)": "onTouched()" + }, + providers: [NUMBER_VALUE_ACCESSOR], + standalone: false + }] + }], null, null); +})(); +var RADIO_VALUE_ACCESSOR = { + provide: NG_VALUE_ACCESSOR, + useExisting: forwardRef(() => RadioControlValueAccessor), + multi: true +}; +function throwNameError() { + throw new RuntimeError(1202, ` + If you define both a name and a formControlName attribute on your radio button, their values + must match. Ex: + `); +} +var RadioControlRegistry = class _RadioControlRegistry { + _accessors = []; + /** + * @description + * Adds a control to the internal registry. For internal use only. + */ + add(control, accessor) { + this._accessors.push([control, accessor]); + } + /** + * @description + * Removes a control from the internal registry. For internal use only. + */ + remove(accessor) { + for (let i = this._accessors.length - 1; i >= 0; --i) { + if (this._accessors[i][1] === accessor) { + this._accessors.splice(i, 1); + return; + } + } + } + /** + * @description + * Selects a radio button. For internal use only. + */ + select(accessor) { + this._accessors.forEach((c) => { + if (this._isSameGroup(c, accessor) && c[1] !== accessor) { + c[1].fireUncheck(accessor.value); + } + }); + } + _isSameGroup(controlPair, accessor) { + if (!controlPair[0].control) return false; + return controlPair[0]._parent === accessor._control._parent && controlPair[1].name === accessor.name; + } + static ɵfac = function RadioControlRegistry_Factory(__ngFactoryType__) { + return new (__ngFactoryType__ || _RadioControlRegistry)(); + }; + static ɵprov = ɵɵdefineInjectable({ + token: _RadioControlRegistry, + factory: _RadioControlRegistry.ɵfac, + providedIn: "root" + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RadioControlRegistry, [{ + type: Injectable, + args: [{ + providedIn: "root" + }] + }], null, null); +})(); +var RadioControlValueAccessor = class _RadioControlValueAccessor extends BuiltInControlValueAccessor { + _registry; + _injector; + /** @internal */ + _state; + /** @internal */ + _control; + /** @internal */ + _fn; + setDisabledStateFired = false; + /** + * The registered callback function called when a change event occurs on the input element. + * Note: we declare `onChange` here (also used as host listener) as a function with no arguments + * to override the `onChange` function (which expects 1 argument) in the parent + * `BaseControlValueAccessor` class. + * @docs-private + */ + onChange = () => { + }; + /** + * @description + * Tracks the name of the radio input element. + */ + name; + /** + * @description + * Tracks the name of the `FormControl` bound to the directive. The name corresponds + * to a key in the parent `FormGroup` or `FormArray`. + */ + formControlName; + /** + * @description + * Tracks the value of the radio input element + */ + value; + callSetDisabledState = inject(CALL_SET_DISABLED_STATE, { + optional: true + }) ?? setDisabledStateDefault; + constructor(renderer, elementRef, _registry, _injector) { + super(renderer, elementRef); + this._registry = _registry; + this._injector = _injector; + } + /** @docs-private */ + ngOnInit() { + this._control = this._injector.get(NgControl); + this._checkName(); + this._registry.add(this._control, this); + } + /** @docs-private */ + ngOnDestroy() { + this._registry.remove(this); + } + /** + * Sets the "checked" property value on the radio input element. + * @docs-private + */ + writeValue(value) { + this._state = value === this.value; + this.setProperty("checked", this._state); + } + /** + * Registers a function called when the control value changes. + * @docs-private + */ + registerOnChange(fn) { + this._fn = fn; + this.onChange = () => { + fn(this.value); + this._registry.select(this); + }; + } + /** @docs-private */ + setDisabledState(isDisabled) { + if (this.setDisabledStateFired || isDisabled || this.callSetDisabledState === "whenDisabledForLegacyCode") { + this.setProperty("disabled", isDisabled); + } + this.setDisabledStateFired = true; + } + /** + * Sets the "value" on the radio input element and unchecks it. + * + * @param value + */ + fireUncheck(value) { + this.writeValue(value); + } + _checkName() { + if (this.name && this.formControlName && this.name !== this.formControlName && (typeof ngDevMode === "undefined" || ngDevMode)) { + throwNameError(); + } + if (!this.name && this.formControlName) this.name = this.formControlName; + } + static ɵfac = function RadioControlValueAccessor_Factory(__ngFactoryType__) { + return new (__ngFactoryType__ || _RadioControlValueAccessor)(ɵɵdirectiveInject(Renderer2), ɵɵdirectiveInject(ElementRef), ɵɵdirectiveInject(RadioControlRegistry), ɵɵdirectiveInject(Injector)); + }; + static ɵdir = ɵɵdefineDirective({ + type: _RadioControlValueAccessor, + selectors: [["input", "type", "radio", "formControlName", ""], ["input", "type", "radio", "formControl", ""], ["input", "type", "radio", "ngModel", ""]], + hostBindings: function RadioControlValueAccessor_HostBindings(rf, ctx) { + if (rf & 1) { + ɵɵlistener("change", function RadioControlValueAccessor_change_HostBindingHandler() { + return ctx.onChange(); + })("blur", function RadioControlValueAccessor_blur_HostBindingHandler() { + return ctx.onTouched(); + }); + } + }, + inputs: { + name: "name", + formControlName: "formControlName", + value: "value" + }, + standalone: false, + features: [ɵɵProvidersFeature([RADIO_VALUE_ACCESSOR]), ɵɵInheritDefinitionFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RadioControlValueAccessor, [{ + type: Directive, + args: [{ + selector: "input[type=radio][formControlName],input[type=radio][formControl],input[type=radio][ngModel]", + host: { + "(change)": "onChange()", + "(blur)": "onTouched()" + }, + providers: [RADIO_VALUE_ACCESSOR], + standalone: false + }] + }], () => [{ + type: Renderer2 + }, { + type: ElementRef + }, { + type: RadioControlRegistry + }, { + type: Injector + }], { + name: [{ + type: Input + }], + formControlName: [{ + type: Input + }], + value: [{ + type: Input + }] + }); +})(); +var RANGE_VALUE_ACCESSOR = { + provide: NG_VALUE_ACCESSOR, + useExisting: forwardRef(() => RangeValueAccessor), + multi: true +}; +var RangeValueAccessor = class _RangeValueAccessor extends BuiltInControlValueAccessor { + /** + * Sets the "value" property on the input element. + * @docs-private + */ + writeValue(value) { + this.setProperty("value", parseFloat(value)); + } + /** + * Registers a function called when the control value changes. + * @docs-private + */ + registerOnChange(fn) { + this.onChange = (value) => { + fn(value == "" ? null : parseFloat(value)); + }; + } + static ɵfac = /* @__PURE__ */ (() => { + let ɵRangeValueAccessor_BaseFactory; + return function RangeValueAccessor_Factory(__ngFactoryType__) { + return (ɵRangeValueAccessor_BaseFactory || (ɵRangeValueAccessor_BaseFactory = ɵɵgetInheritedFactory(_RangeValueAccessor)))(__ngFactoryType__ || _RangeValueAccessor); + }; + })(); + static ɵdir = ɵɵdefineDirective({ + type: _RangeValueAccessor, + selectors: [["input", "type", "range", "formControlName", ""], ["input", "type", "range", "formControl", ""], ["input", "type", "range", "ngModel", ""]], + hostBindings: function RangeValueAccessor_HostBindings(rf, ctx) { + if (rf & 1) { + ɵɵlistener("change", function RangeValueAccessor_change_HostBindingHandler($event) { + return ctx.onChange($event.target.value); + })("input", function RangeValueAccessor_input_HostBindingHandler($event) { + return ctx.onChange($event.target.value); + })("blur", function RangeValueAccessor_blur_HostBindingHandler() { + return ctx.onTouched(); + }); + } + }, + standalone: false, + features: [ɵɵProvidersFeature([RANGE_VALUE_ACCESSOR]), ɵɵInheritDefinitionFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RangeValueAccessor, [{ + type: Directive, + args: [{ + selector: "input[type=range][formControlName],input[type=range][formControl],input[type=range][ngModel]", + host: { + "(change)": "onChange($any($event.target).value)", + "(input)": "onChange($any($event.target).value)", + "(blur)": "onTouched()" + }, + providers: [RANGE_VALUE_ACCESSOR], + standalone: false + }] + }], null, null); +})(); +var NG_MODEL_WITH_FORM_CONTROL_WARNING = new InjectionToken(ngDevMode ? "NgModelWithFormControlWarning" : ""); +var formControlBinding = { + provide: NgControl, + useExisting: forwardRef(() => FormControlDirective) +}; +var FormControlDirective = class _FormControlDirective extends NgControl { + _ngModelWarningConfig; + callSetDisabledState; + /** + * Internal reference to the view model value. + * @docs-private + */ + viewModel; + /** + * @description + * Tracks the `FormControl` instance bound to the directive. + */ + form; + /** + * @description + * Triggers a warning in dev mode that this input should not be used with reactive forms. + */ + set isDisabled(isDisabled) { + if (typeof ngDevMode === "undefined" || ngDevMode) { + console.warn(disabledAttrWarning); + } + } + // TODO(kara): remove next 4 properties once deprecation period is over + /** @deprecated as of v6 */ + model; + /** @deprecated as of v6 */ + update = new EventEmitter(); + /** + * @description + * Static property used to track whether any ngModel warnings have been sent across + * all instances of FormControlDirective. Used to support warning config of "once". + * + * @internal + */ + static _ngModelWarningSentOnce = false; + /** + * @description + * Instance property used to track whether an ngModel warning has been sent out for this + * particular `FormControlDirective` instance. Used to support warning config of "always". + * + * @internal + */ + _ngModelWarningSent = false; + constructor(validators, asyncValidators, valueAccessors, _ngModelWarningConfig, callSetDisabledState) { + super(); + this._ngModelWarningConfig = _ngModelWarningConfig; + this.callSetDisabledState = callSetDisabledState; + this._setValidators(validators); + this._setAsyncValidators(asyncValidators); + this.valueAccessor = selectValueAccessor(this, valueAccessors); + } + /** @docs-private */ + ngOnChanges(changes) { + if (this._isControlChanged(changes)) { + const previousForm = changes["form"].previousValue; + if (previousForm) { + cleanUpControl( + previousForm, + this, + /* validateControlPresenceOnChange */ + false + ); + } + setUpControl(this.form, this, this.callSetDisabledState); + this.form.updateValueAndValidity({ + emitEvent: false + }); + } + if (isPropertyUpdated(changes, this.viewModel)) { + if (typeof ngDevMode === "undefined" || ngDevMode) { + _ngModelWarning("formControl", _FormControlDirective, this, this._ngModelWarningConfig); + } + this.form.setValue(this.model); + this.viewModel = this.model; + } + } + /** @docs-private */ + ngOnDestroy() { + if (this.form) { + cleanUpControl( + this.form, + this, + /* validateControlPresenceOnChange */ + false + ); + } + } + /** + * @description + * Returns an array that represents the path from the top-level form to this control. + * Each index is the string name of the control on that level. + */ + get path() { + return []; + } + /** + * @description + * The `FormControl` bound to this directive. + */ + get control() { + return this.form; + } + /** + * @description + * Sets the new value for the view model and emits an `ngModelChange` event. + * + * @param newValue The new value for the view model. + */ + viewToModelUpdate(newValue) { + this.viewModel = newValue; + this.update.emit(newValue); + } + _isControlChanged(changes) { + return changes.hasOwnProperty("form"); + } + static ɵfac = function FormControlDirective_Factory(__ngFactoryType__) { + return new (__ngFactoryType__ || _FormControlDirective)(ɵɵdirectiveInject(NG_VALIDATORS, 10), ɵɵdirectiveInject(NG_ASYNC_VALIDATORS, 10), ɵɵdirectiveInject(NG_VALUE_ACCESSOR, 10), ɵɵdirectiveInject(NG_MODEL_WITH_FORM_CONTROL_WARNING, 8), ɵɵdirectiveInject(CALL_SET_DISABLED_STATE, 8)); + }; + static ɵdir = ɵɵdefineDirective({ + type: _FormControlDirective, + selectors: [["", "formControl", ""]], + inputs: { + form: [0, "formControl", "form"], + isDisabled: [0, "disabled", "isDisabled"], + model: [0, "ngModel", "model"] + }, + outputs: { + update: "ngModelChange" + }, + exportAs: ["ngForm"], + standalone: false, + features: [ɵɵProvidersFeature([formControlBinding]), ɵɵInheritDefinitionFeature, ɵɵNgOnChangesFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FormControlDirective, [{ + type: Directive, + args: [{ + selector: "[formControl]", + providers: [formControlBinding], + exportAs: "ngForm", + standalone: false + }] + }], () => [{ + type: void 0, + decorators: [{ + type: Optional + }, { + type: Self + }, { + type: Inject, + args: [NG_VALIDATORS] + }] + }, { + type: void 0, + decorators: [{ + type: Optional + }, { + type: Self + }, { + type: Inject, + args: [NG_ASYNC_VALIDATORS] + }] + }, { + type: void 0, + decorators: [{ + type: Optional + }, { + type: Self + }, { + type: Inject, + args: [NG_VALUE_ACCESSOR] + }] + }, { + type: void 0, + decorators: [{ + type: Optional + }, { + type: Inject, + args: [NG_MODEL_WITH_FORM_CONTROL_WARNING] + }] + }, { + type: void 0, + decorators: [{ + type: Optional + }, { + type: Inject, + args: [CALL_SET_DISABLED_STATE] + }] + }], { + form: [{ + type: Input, + args: ["formControl"] + }], + isDisabled: [{ + type: Input, + args: ["disabled"] + }], + model: [{ + type: Input, + args: ["ngModel"] + }], + update: [{ + type: Output, + args: ["ngModelChange"] + }] + }); +})(); +var formDirectiveProvider = { + provide: ControlContainer, + useExisting: forwardRef(() => FormGroupDirective) +}; +var FormGroupDirective = class _FormGroupDirective extends ControlContainer { + callSetDisabledState; + /** + * @description + * Reports whether the form submission has been triggered. + */ + get submitted() { + return untracked(this._submittedReactive); + } + // TODO(atscott): Remove once invalid API usage is cleaned up internally + set submitted(value) { + this._submittedReactive.set(value); + } + /** @internal */ + _submitted = computed(() => this._submittedReactive(), ...ngDevMode ? [{ + debugName: "_submitted" + }] : []); + _submittedReactive = signal(false, ...ngDevMode ? [{ + debugName: "_submittedReactive" + }] : []); + /** + * Reference to an old form group input value, which is needed to cleanup + * old instance in case it was replaced with a new one. + */ + _oldForm; + /** + * Callback that should be invoked when controls in FormGroup or FormArray collection change + * (added or removed). This callback triggers corresponding DOM updates. + */ + _onCollectionChange = () => this._updateDomValue(); + /** + * @description + * Tracks the list of added `FormControlName` instances + */ + directives = []; + /** + * @description + * Tracks the `FormGroup` bound to this directive. + */ + form = null; + /** + * @description + * Emits an event when the form submission has been triggered. + */ + ngSubmit = new EventEmitter(); + constructor(validators, asyncValidators, callSetDisabledState) { + super(); + this.callSetDisabledState = callSetDisabledState; + this._setValidators(validators); + this._setAsyncValidators(asyncValidators); + } + /** @docs-private */ + ngOnChanges(changes) { + if ((typeof ngDevMode === "undefined" || ngDevMode) && !this.form) { + throw missingFormException(); + } + if (changes.hasOwnProperty("form")) { + this._updateValidators(); + this._updateDomValue(); + this._updateRegistrations(); + this._oldForm = this.form; + } + } + /** @docs-private */ + ngOnDestroy() { + if (this.form) { + cleanUpValidators(this.form, this); + if (this.form._onCollectionChange === this._onCollectionChange) { + this.form._registerOnCollectionChange(() => { + }); + } + } + } + /** + * @description + * Returns this directive's instance. + */ + get formDirective() { + return this; + } + /** + * @description + * Returns the `FormGroup` bound to this directive. + */ + get control() { + return this.form; + } + /** + * @description + * Returns an array representing the path to this group. Because this directive + * always lives at the top level of a form, it always an empty array. + */ + get path() { + return []; + } + /** + * @description + * Method that sets up the control directive in this group, re-calculates its value + * and validity, and adds the instance to the internal list of directives. + * + * @param dir The `FormControlName` directive instance. + */ + addControl(dir) { + const ctrl = this.form.get(dir.path); + setUpControl(ctrl, dir, this.callSetDisabledState); + ctrl.updateValueAndValidity({ + emitEvent: false + }); + this.directives.push(dir); + return ctrl; + } + /** + * @description + * Retrieves the `FormControl` instance from the provided `FormControlName` directive + * + * @param dir The `FormControlName` directive instance. + */ + getControl(dir) { + return this.form.get(dir.path); + } + /** + * @description + * Removes the `FormControlName` instance from the internal list of directives + * + * @param dir The `FormControlName` directive instance. + */ + removeControl(dir) { + cleanUpControl( + dir.control || null, + dir, + /* validateControlPresenceOnChange */ + false + ); + removeListItem$1(this.directives, dir); + } + /** + * Adds a new `FormGroupName` directive instance to the form. + * + * @param dir The `FormGroupName` directive instance. + */ + addFormGroup(dir) { + this._setUpFormContainer(dir); + } + /** + * Performs the necessary cleanup when a `FormGroupName` directive instance is removed from the + * view. + * + * @param dir The `FormGroupName` directive instance. + */ + removeFormGroup(dir) { + this._cleanUpFormContainer(dir); + } + /** + * @description + * Retrieves the `FormGroup` for a provided `FormGroupName` directive instance + * + * @param dir The `FormGroupName` directive instance. + */ + getFormGroup(dir) { + return this.form.get(dir.path); + } + /** + * Performs the necessary setup when a `FormArrayName` directive instance is added to the view. + * + * @param dir The `FormArrayName` directive instance. + */ + addFormArray(dir) { + this._setUpFormContainer(dir); + } + /** + * Performs the necessary cleanup when a `FormArrayName` directive instance is removed from the + * view. + * + * @param dir The `FormArrayName` directive instance. + */ + removeFormArray(dir) { + this._cleanUpFormContainer(dir); + } + /** + * @description + * Retrieves the `FormArray` for a provided `FormArrayName` directive instance. + * + * @param dir The `FormArrayName` directive instance. + */ + getFormArray(dir) { + return this.form.get(dir.path); + } + /** + * Sets the new value for the provided `FormControlName` directive. + * + * @param dir The `FormControlName` directive instance. + * @param value The new value for the directive's control. + */ + updateModel(dir, value) { + const ctrl = this.form.get(dir.path); + ctrl.setValue(value); + } + /** + * @description + * Method called with the "submit" event is triggered on the form. + * Triggers the `ngSubmit` emitter to emit the "submit" event as its payload. + * + * @param $event The "submit" event object + */ + onSubmit($event) { + this._submittedReactive.set(true); + syncPendingControls(this.form, this.directives); + this.ngSubmit.emit($event); + this.form._events.next(new FormSubmittedEvent(this.control)); + return $event?.target?.method === "dialog"; + } + /** + * @description + * Method called when the "reset" event is triggered on the form. + */ + onReset() { + this.resetForm(); + } + /** + * @description + * Resets the form to an initial value and resets its submitted status. + * + * @param value The new value for the form, `undefined` by default + */ + resetForm(value = void 0, options = {}) { + this.form.reset(value, options); + this._submittedReactive.set(false); + if (options?.emitEvent !== false) { + this.form._events.next(new FormResetEvent(this.form)); + } + } + /** @internal */ + _updateDomValue() { + this.directives.forEach((dir) => { + const oldCtrl = dir.control; + const newCtrl = this.form.get(dir.path); + if (oldCtrl !== newCtrl) { + cleanUpControl(oldCtrl || null, dir); + if (isFormControl(newCtrl)) { + setUpControl(newCtrl, dir, this.callSetDisabledState); + dir.control = newCtrl; + } + } + }); + this.form._updateTreeValidity({ + emitEvent: false + }); + } + _setUpFormContainer(dir) { + const ctrl = this.form.get(dir.path); + setUpFormContainer(ctrl, dir); + ctrl.updateValueAndValidity({ + emitEvent: false + }); + } + _cleanUpFormContainer(dir) { + if (this.form) { + const ctrl = this.form.get(dir.path); + if (ctrl) { + const isControlUpdated = cleanUpFormContainer(ctrl, dir); + if (isControlUpdated) { + ctrl.updateValueAndValidity({ + emitEvent: false + }); + } + } + } + } + _updateRegistrations() { + this.form._registerOnCollectionChange(this._onCollectionChange); + if (this._oldForm) { + this._oldForm._registerOnCollectionChange(() => { + }); + } + } + _updateValidators() { + setUpValidators(this.form, this); + if (this._oldForm) { + cleanUpValidators(this._oldForm, this); + } + } + static ɵfac = function FormGroupDirective_Factory(__ngFactoryType__) { + return new (__ngFactoryType__ || _FormGroupDirective)(ɵɵdirectiveInject(NG_VALIDATORS, 10), ɵɵdirectiveInject(NG_ASYNC_VALIDATORS, 10), ɵɵdirectiveInject(CALL_SET_DISABLED_STATE, 8)); + }; + static ɵdir = ɵɵdefineDirective({ + type: _FormGroupDirective, + selectors: [["", "formGroup", ""]], + hostBindings: function FormGroupDirective_HostBindings(rf, ctx) { + if (rf & 1) { + ɵɵlistener("submit", function FormGroupDirective_submit_HostBindingHandler($event) { + return ctx.onSubmit($event); + })("reset", function FormGroupDirective_reset_HostBindingHandler() { + return ctx.onReset(); + }); + } + }, + inputs: { + form: [0, "formGroup", "form"] + }, + outputs: { + ngSubmit: "ngSubmit" + }, + exportAs: ["ngForm"], + standalone: false, + features: [ɵɵProvidersFeature([formDirectiveProvider]), ɵɵInheritDefinitionFeature, ɵɵNgOnChangesFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FormGroupDirective, [{ + type: Directive, + args: [{ + selector: "[formGroup]", + providers: [formDirectiveProvider], + host: { + "(submit)": "onSubmit($event)", + "(reset)": "onReset()" + }, + exportAs: "ngForm", + standalone: false + }] + }], () => [{ + type: void 0, + decorators: [{ + type: Optional + }, { + type: Self + }, { + type: Inject, + args: [NG_VALIDATORS] + }] + }, { + type: void 0, + decorators: [{ + type: Optional + }, { + type: Self + }, { + type: Inject, + args: [NG_ASYNC_VALIDATORS] + }] + }, { + type: void 0, + decorators: [{ + type: Optional + }, { + type: Inject, + args: [CALL_SET_DISABLED_STATE] + }] + }], { + form: [{ + type: Input, + args: ["formGroup"] + }], + ngSubmit: [{ + type: Output + }] + }); +})(); +var formGroupNameProvider = { + provide: ControlContainer, + useExisting: forwardRef(() => FormGroupName) +}; +var FormGroupName = class _FormGroupName extends AbstractFormGroupDirective { + /** + * @description + * Tracks the name of the `FormGroup` bound to the directive. The name corresponds + * to a key in the parent `FormGroup` or `FormArray`. + * Accepts a name as a string or a number. + * The name in the form of a string is useful for individual forms, + * while the numerical form allows for form groups to be bound + * to indices when iterating over groups in a `FormArray`. + */ + name = null; + constructor(parent, validators, asyncValidators) { + super(); + this._parent = parent; + this._setValidators(validators); + this._setAsyncValidators(asyncValidators); + } + /** @internal */ + _checkParentType() { + if (hasInvalidParent(this._parent) && (typeof ngDevMode === "undefined" || ngDevMode)) { + throw groupParentException(); + } + } + static ɵfac = function FormGroupName_Factory(__ngFactoryType__) { + return new (__ngFactoryType__ || _FormGroupName)(ɵɵdirectiveInject(ControlContainer, 13), ɵɵdirectiveInject(NG_VALIDATORS, 10), ɵɵdirectiveInject(NG_ASYNC_VALIDATORS, 10)); + }; + static ɵdir = ɵɵdefineDirective({ + type: _FormGroupName, + selectors: [["", "formGroupName", ""]], + inputs: { + name: [0, "formGroupName", "name"] + }, + standalone: false, + features: [ɵɵProvidersFeature([formGroupNameProvider]), ɵɵInheritDefinitionFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FormGroupName, [{ + type: Directive, + args: [{ + selector: "[formGroupName]", + providers: [formGroupNameProvider], + standalone: false + }] + }], () => [{ + type: ControlContainer, + decorators: [{ + type: Optional + }, { + type: Host + }, { + type: SkipSelf + }] + }, { + type: void 0, + decorators: [{ + type: Optional + }, { + type: Self + }, { + type: Inject, + args: [NG_VALIDATORS] + }] + }, { + type: void 0, + decorators: [{ + type: Optional + }, { + type: Self + }, { + type: Inject, + args: [NG_ASYNC_VALIDATORS] + }] + }], { + name: [{ + type: Input, + args: ["formGroupName"] + }] + }); +})(); +var formArrayNameProvider = { + provide: ControlContainer, + useExisting: forwardRef(() => FormArrayName) +}; +var FormArrayName = class _FormArrayName extends ControlContainer { + /** @internal */ + _parent; + /** + * @description + * Tracks the name of the `FormArray` bound to the directive. The name corresponds + * to a key in the parent `FormGroup` or `FormArray`. + * Accepts a name as a string or a number. + * The name in the form of a string is useful for individual forms, + * while the numerical form allows for form arrays to be bound + * to indices when iterating over arrays in a `FormArray`. + */ + name = null; + constructor(parent, validators, asyncValidators) { + super(); + this._parent = parent; + this._setValidators(validators); + this._setAsyncValidators(asyncValidators); + } + /** + * A lifecycle method called when the directive's inputs are initialized. For internal use only. + * @throws If the directive does not have a valid parent. + * @docs-private + */ + ngOnInit() { + if (hasInvalidParent(this._parent) && (typeof ngDevMode === "undefined" || ngDevMode)) { + throw arrayParentException(); + } + this.formDirective.addFormArray(this); + } + /** + * A lifecycle method called before the directive's instance is destroyed. For internal use only. + * @docs-private + */ + ngOnDestroy() { + this.formDirective?.removeFormArray(this); + } + /** + * @description + * The `FormArray` bound to this directive. + */ + get control() { + return this.formDirective.getFormArray(this); + } + /** + * @description + * The top-level directive for this group if present, otherwise null. + */ + get formDirective() { + return this._parent ? this._parent.formDirective : null; + } + /** + * @description + * Returns an array that represents the path from the top-level form to this control. + * Each index is the string name of the control on that level. + */ + get path() { + return controlPath(this.name == null ? this.name : this.name.toString(), this._parent); + } + static ɵfac = function FormArrayName_Factory(__ngFactoryType__) { + return new (__ngFactoryType__ || _FormArrayName)(ɵɵdirectiveInject(ControlContainer, 13), ɵɵdirectiveInject(NG_VALIDATORS, 10), ɵɵdirectiveInject(NG_ASYNC_VALIDATORS, 10)); + }; + static ɵdir = ɵɵdefineDirective({ + type: _FormArrayName, + selectors: [["", "formArrayName", ""]], + inputs: { + name: [0, "formArrayName", "name"] + }, + standalone: false, + features: [ɵɵProvidersFeature([formArrayNameProvider]), ɵɵInheritDefinitionFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FormArrayName, [{ + type: Directive, + args: [{ + selector: "[formArrayName]", + providers: [formArrayNameProvider], + standalone: false + }] + }], () => [{ + type: ControlContainer, + decorators: [{ + type: Optional + }, { + type: Host + }, { + type: SkipSelf + }] + }, { + type: void 0, + decorators: [{ + type: Optional + }, { + type: Self + }, { + type: Inject, + args: [NG_VALIDATORS] + }] + }, { + type: void 0, + decorators: [{ + type: Optional + }, { + type: Self + }, { + type: Inject, + args: [NG_ASYNC_VALIDATORS] + }] + }], { + name: [{ + type: Input, + args: ["formArrayName"] + }] + }); +})(); +function hasInvalidParent(parent) { + return !(parent instanceof FormGroupName) && !(parent instanceof FormGroupDirective) && !(parent instanceof FormArrayName); +} +var controlNameBinding = { + provide: NgControl, + useExisting: forwardRef(() => FormControlName) +}; +var FormControlName = class _FormControlName extends NgControl { + _ngModelWarningConfig; + _added = false; + /** + * Internal reference to the view model value. + * @internal + */ + viewModel; + /** + * @description + * Tracks the `FormControl` instance bound to the directive. + */ + control; + /** + * @description + * Tracks the name of the `FormControl` bound to the directive. The name corresponds + * to a key in the parent `FormGroup` or `FormArray`. + * Accepts a name as a string or a number. + * The name in the form of a string is useful for individual forms, + * while the numerical form allows for form controls to be bound + * to indices when iterating over controls in a `FormArray`. + */ + name = null; + /** + * @description + * Triggers a warning in dev mode that this input should not be used with reactive forms. + */ + set isDisabled(isDisabled) { + if (typeof ngDevMode === "undefined" || ngDevMode) { + console.warn(disabledAttrWarning); + } + } + // TODO(kara): remove next 4 properties once deprecation period is over + /** @deprecated as of v6 */ + model; + /** @deprecated as of v6 */ + update = new EventEmitter(); + /** + * @description + * Static property used to track whether any ngModel warnings have been sent across + * all instances of FormControlName. Used to support warning config of "once". + * + * @internal + */ + static _ngModelWarningSentOnce = false; + /** + * @description + * Instance property used to track whether an ngModel warning has been sent out for this + * particular FormControlName instance. Used to support warning config of "always". + * + * @internal + */ + _ngModelWarningSent = false; + constructor(parent, validators, asyncValidators, valueAccessors, _ngModelWarningConfig) { + super(); + this._ngModelWarningConfig = _ngModelWarningConfig; + this._parent = parent; + this._setValidators(validators); + this._setAsyncValidators(asyncValidators); + this.valueAccessor = selectValueAccessor(this, valueAccessors); + } + /** @docs-private */ + ngOnChanges(changes) { + if (!this._added) this._setUpControl(); + if (isPropertyUpdated(changes, this.viewModel)) { + if (typeof ngDevMode === "undefined" || ngDevMode) { + _ngModelWarning("formControlName", _FormControlName, this, this._ngModelWarningConfig); + } + this.viewModel = this.model; + this.formDirective.updateModel(this, this.model); + } + } + /** @docs-private */ + ngOnDestroy() { + if (this.formDirective) { + this.formDirective.removeControl(this); + } + } + /** + * @description + * Sets the new value for the view model and emits an `ngModelChange` event. + * + * @param newValue The new value for the view model. + */ + viewToModelUpdate(newValue) { + this.viewModel = newValue; + this.update.emit(newValue); + } + /** + * @description + * Returns an array that represents the path from the top-level form to this control. + * Each index is the string name of the control on that level. + */ + get path() { + return controlPath(this.name == null ? this.name : this.name.toString(), this._parent); + } + /** + * @description + * The top-level directive for this group if present, otherwise null. + */ + get formDirective() { + return this._parent ? this._parent.formDirective : null; + } + _setUpControl() { + if (typeof ngDevMode === "undefined" || ngDevMode) { + checkParentType(this._parent, this.name); + } + this.control = this.formDirective.addControl(this); + this._added = true; + } + static ɵfac = function FormControlName_Factory(__ngFactoryType__) { + return new (__ngFactoryType__ || _FormControlName)(ɵɵdirectiveInject(ControlContainer, 13), ɵɵdirectiveInject(NG_VALIDATORS, 10), ɵɵdirectiveInject(NG_ASYNC_VALIDATORS, 10), ɵɵdirectiveInject(NG_VALUE_ACCESSOR, 10), ɵɵdirectiveInject(NG_MODEL_WITH_FORM_CONTROL_WARNING, 8)); + }; + static ɵdir = ɵɵdefineDirective({ + type: _FormControlName, + selectors: [["", "formControlName", ""]], + inputs: { + name: [0, "formControlName", "name"], + isDisabled: [0, "disabled", "isDisabled"], + model: [0, "ngModel", "model"] + }, + outputs: { + update: "ngModelChange" + }, + standalone: false, + features: [ɵɵProvidersFeature([controlNameBinding]), ɵɵInheritDefinitionFeature, ɵɵNgOnChangesFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FormControlName, [{ + type: Directive, + args: [{ + selector: "[formControlName]", + providers: [controlNameBinding], + standalone: false + }] + }], () => [{ + type: ControlContainer, + decorators: [{ + type: Optional + }, { + type: Host + }, { + type: SkipSelf + }] + }, { + type: void 0, + decorators: [{ + type: Optional + }, { + type: Self + }, { + type: Inject, + args: [NG_VALIDATORS] + }] + }, { + type: void 0, + decorators: [{ + type: Optional + }, { + type: Self + }, { + type: Inject, + args: [NG_ASYNC_VALIDATORS] + }] + }, { + type: void 0, + decorators: [{ + type: Optional + }, { + type: Self + }, { + type: Inject, + args: [NG_VALUE_ACCESSOR] + }] + }, { + type: void 0, + decorators: [{ + type: Optional + }, { + type: Inject, + args: [NG_MODEL_WITH_FORM_CONTROL_WARNING] + }] + }], { + name: [{ + type: Input, + args: ["formControlName"] + }], + isDisabled: [{ + type: Input, + args: ["disabled"] + }], + model: [{ + type: Input, + args: ["ngModel"] + }], + update: [{ + type: Output, + args: ["ngModelChange"] + }] + }); +})(); +function checkParentType(parent, name) { + if (!(parent instanceof FormGroupName) && parent instanceof AbstractFormGroupDirective) { + throw ngModelGroupException(); + } else if (!(parent instanceof FormGroupName) && !(parent instanceof FormGroupDirective) && !(parent instanceof FormArrayName)) { + throw controlParentException(name); + } +} +var SELECT_VALUE_ACCESSOR = { + provide: NG_VALUE_ACCESSOR, + useExisting: forwardRef(() => SelectControlValueAccessor), + multi: true +}; +function _buildValueString$1(id, value) { + if (id == null) return `${value}`; + if (value && typeof value === "object") value = "Object"; + return `${id}: ${value}`.slice(0, 50); +} +function _extractId$1(valueString) { + return valueString.split(":")[0]; +} +var SelectControlValueAccessor = class _SelectControlValueAccessor extends BuiltInControlValueAccessor { + /** @docs-private */ + value; + /** @internal */ + _optionMap = /* @__PURE__ */ new Map(); + /** @internal */ + _idCounter = 0; + /** + * @description + * Tracks the option comparison algorithm for tracking identities when + * checking for changes. + */ + set compareWith(fn) { + if (typeof fn !== "function" && (typeof ngDevMode === "undefined" || ngDevMode)) { + throw new RuntimeError(1201, `compareWith must be a function, but received ${JSON.stringify(fn)}`); + } + this._compareWith = fn; + } + _compareWith = Object.is; + // We need this because we might be in the process of destroying the root + // injector, which is marked as destroyed before running destroy hooks. + // Attempting to use afterNextRender with the node injector would evntually + // run into that already destroyed injector. + appRefInjector = inject(ApplicationRef).injector; + destroyRef = inject(DestroyRef); + cdr = inject(ChangeDetectorRef); + _queuedWrite = false; + /** + * This is needed to efficiently set the select value when adding/removing options. If + * writeValue is instead called for every added/removed option, this results in exponentially + * more _compareValue calls than the number of option elements (issue #41330). + * + * Secondly, calling writeValue when rendering individual option elements instead of after they + * are all rendered caused an issue in Safari and IE 11 where the first option element failed + * to be deselected when no option matched the select ngModel. This was because Angular would + * set the select element's value property before appending the option's child text node to the + * DOM (issue #14505). + * + * Finally, this approach is necessary to avoid an issue with delayed element removal when + * using the animations module (in all browsers). Otherwise when a selected option is removed + * (so no option matches the ngModel anymore), Angular would change the select element value + * before actually removing the option from the DOM. Then when the option is finally removed + * from the DOM, the browser would change the select value to that of the first option, even + * though it doesn't match the ngModel (issue #18430). + * + * @internal + */ + _writeValueAfterRender() { + if (this._queuedWrite || this.appRefInjector.destroyed) { + return; + } + this._queuedWrite = true; + afterNextRender({ + write: () => { + if (this.destroyRef.destroyed) { + return; + } + this._queuedWrite = false; + this.writeValue(this.value); + } + }, { + injector: this.appRefInjector + }); + } + /** + * Sets the "value" property on the select element. + * @docs-private + */ + writeValue(value) { + this.cdr.markForCheck(); + this.value = value; + const id = this._getOptionId(value); + const valueString = _buildValueString$1(id, value); + this.setProperty("value", valueString); + } + /** + * Registers a function called when the control value changes. + * @docs-private + */ + registerOnChange(fn) { + this.onChange = (valueString) => { + this.value = this._getOptionValue(valueString); + fn(this.value); + }; + } + /** @internal */ + _registerOption() { + return (this._idCounter++).toString(); + } + /** @internal */ + _getOptionId(value) { + for (const id of this._optionMap.keys()) { + if (this._compareWith(this._optionMap.get(id), value)) return id; + } + return null; + } + /** @internal */ + _getOptionValue(valueString) { + const id = _extractId$1(valueString); + return this._optionMap.has(id) ? this._optionMap.get(id) : valueString; + } + static ɵfac = /* @__PURE__ */ (() => { + let ɵSelectControlValueAccessor_BaseFactory; + return function SelectControlValueAccessor_Factory(__ngFactoryType__) { + return (ɵSelectControlValueAccessor_BaseFactory || (ɵSelectControlValueAccessor_BaseFactory = ɵɵgetInheritedFactory(_SelectControlValueAccessor)))(__ngFactoryType__ || _SelectControlValueAccessor); + }; + })(); + static ɵdir = ɵɵdefineDirective({ + type: _SelectControlValueAccessor, + selectors: [["select", "formControlName", "", 3, "multiple", ""], ["select", "formControl", "", 3, "multiple", ""], ["select", "ngModel", "", 3, "multiple", ""]], + hostBindings: function SelectControlValueAccessor_HostBindings(rf, ctx) { + if (rf & 1) { + ɵɵlistener("change", function SelectControlValueAccessor_change_HostBindingHandler($event) { + return ctx.onChange($event.target.value); + })("blur", function SelectControlValueAccessor_blur_HostBindingHandler() { + return ctx.onTouched(); + }); + } + }, + inputs: { + compareWith: "compareWith" + }, + standalone: false, + features: [ɵɵProvidersFeature([SELECT_VALUE_ACCESSOR]), ɵɵInheritDefinitionFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(SelectControlValueAccessor, [{ + type: Directive, + args: [{ + selector: "select:not([multiple])[formControlName],select:not([multiple])[formControl],select:not([multiple])[ngModel]", + host: { + "(change)": "onChange($any($event.target).value)", + "(blur)": "onTouched()" + }, + providers: [SELECT_VALUE_ACCESSOR], + standalone: false + }] + }], null, { + compareWith: [{ + type: Input + }] + }); +})(); +var NgSelectOption = class _NgSelectOption { + _element; + _renderer; + _select; + /** + * @description + * ID of the option element + */ + id; + constructor(_element, _renderer, _select) { + this._element = _element; + this._renderer = _renderer; + this._select = _select; + if (this._select) this.id = this._select._registerOption(); + } + /** + * @description + * Tracks the value bound to the option element. Unlike the value binding, + * ngValue supports binding to objects. + */ + set ngValue(value) { + if (this._select == null) return; + this._select._optionMap.set(this.id, value); + this._setElementValue(_buildValueString$1(this.id, value)); + this._select._writeValueAfterRender(); + } + /** + * @description + * Tracks simple string values bound to the option element. + * For objects, use the `ngValue` input binding. + */ + set value(value) { + this._setElementValue(value); + if (this._select) this._select._writeValueAfterRender(); + } + /** @internal */ + _setElementValue(value) { + this._renderer.setProperty(this._element.nativeElement, "value", value); + } + /** @docs-private */ + ngOnDestroy() { + if (this._select) { + this._select._optionMap.delete(this.id); + this._select._writeValueAfterRender(); + } + } + static ɵfac = function NgSelectOption_Factory(__ngFactoryType__) { + return new (__ngFactoryType__ || _NgSelectOption)(ɵɵdirectiveInject(ElementRef), ɵɵdirectiveInject(Renderer2), ɵɵdirectiveInject(SelectControlValueAccessor, 9)); + }; + static ɵdir = ɵɵdefineDirective({ + type: _NgSelectOption, + selectors: [["option"]], + inputs: { + ngValue: "ngValue", + value: "value" + }, + standalone: false + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgSelectOption, [{ + type: Directive, + args: [{ + selector: "option", + standalone: false + }] + }], () => [{ + type: ElementRef + }, { + type: Renderer2 + }, { + type: SelectControlValueAccessor, + decorators: [{ + type: Optional + }, { + type: Host + }] + }], { + ngValue: [{ + type: Input, + args: ["ngValue"] + }], + value: [{ + type: Input, + args: ["value"] + }] + }); +})(); +var SELECT_MULTIPLE_VALUE_ACCESSOR = { + provide: NG_VALUE_ACCESSOR, + useExisting: forwardRef(() => SelectMultipleControlValueAccessor), + multi: true +}; +function _buildValueString(id, value) { + if (id == null) return `${value}`; + if (typeof value === "string") value = `'${value}'`; + if (value && typeof value === "object") value = "Object"; + return `${id}: ${value}`.slice(0, 50); +} +function _extractId(valueString) { + return valueString.split(":")[0]; +} +var SelectMultipleControlValueAccessor = class _SelectMultipleControlValueAccessor extends BuiltInControlValueAccessor { + /** + * The current value. + * @docs-private + */ + value; + /** @internal */ + _optionMap = /* @__PURE__ */ new Map(); + /** @internal */ + _idCounter = 0; + /** + * @description + * Tracks the option comparison algorithm for tracking identities when + * checking for changes. + */ + set compareWith(fn) { + if (typeof fn !== "function" && (typeof ngDevMode === "undefined" || ngDevMode)) { + throw new RuntimeError(1201, `compareWith must be a function, but received ${JSON.stringify(fn)}`); + } + this._compareWith = fn; + } + _compareWith = Object.is; + /** + * Sets the "value" property on one or of more of the select's options. + * @docs-private + */ + writeValue(value) { + this.value = value; + let optionSelectedStateSetter; + if (Array.isArray(value)) { + const ids = value.map((v) => this._getOptionId(v)); + optionSelectedStateSetter = (opt, o) => { + opt._setSelected(ids.indexOf(o.toString()) > -1); + }; + } else { + optionSelectedStateSetter = (opt, o) => { + opt._setSelected(false); + }; + } + this._optionMap.forEach(optionSelectedStateSetter); + } + /** + * Registers a function called when the control value changes + * and writes an array of the selected options. + * @docs-private + */ + registerOnChange(fn) { + this.onChange = (element) => { + const selected = []; + const selectedOptions = element.selectedOptions; + if (selectedOptions !== void 0) { + const options = selectedOptions; + for (let i = 0; i < options.length; i++) { + const opt = options[i]; + const val = this._getOptionValue(opt.value); + selected.push(val); + } + } else { + const options = element.options; + for (let i = 0; i < options.length; i++) { + const opt = options[i]; + if (opt.selected) { + const val = this._getOptionValue(opt.value); + selected.push(val); + } + } + } + this.value = selected; + fn(selected); + }; + } + /** @internal */ + _registerOption(value) { + const id = (this._idCounter++).toString(); + this._optionMap.set(id, value); + return id; + } + /** @internal */ + _getOptionId(value) { + for (const id of this._optionMap.keys()) { + if (this._compareWith(this._optionMap.get(id)._value, value)) return id; + } + return null; + } + /** @internal */ + _getOptionValue(valueString) { + const id = _extractId(valueString); + return this._optionMap.has(id) ? this._optionMap.get(id)._value : valueString; + } + static ɵfac = /* @__PURE__ */ (() => { + let ɵSelectMultipleControlValueAccessor_BaseFactory; + return function SelectMultipleControlValueAccessor_Factory(__ngFactoryType__) { + return (ɵSelectMultipleControlValueAccessor_BaseFactory || (ɵSelectMultipleControlValueAccessor_BaseFactory = ɵɵgetInheritedFactory(_SelectMultipleControlValueAccessor)))(__ngFactoryType__ || _SelectMultipleControlValueAccessor); + }; + })(); + static ɵdir = ɵɵdefineDirective({ + type: _SelectMultipleControlValueAccessor, + selectors: [["select", "multiple", "", "formControlName", ""], ["select", "multiple", "", "formControl", ""], ["select", "multiple", "", "ngModel", ""]], + hostBindings: function SelectMultipleControlValueAccessor_HostBindings(rf, ctx) { + if (rf & 1) { + ɵɵlistener("change", function SelectMultipleControlValueAccessor_change_HostBindingHandler($event) { + return ctx.onChange($event.target); + })("blur", function SelectMultipleControlValueAccessor_blur_HostBindingHandler() { + return ctx.onTouched(); + }); + } + }, + inputs: { + compareWith: "compareWith" + }, + standalone: false, + features: [ɵɵProvidersFeature([SELECT_MULTIPLE_VALUE_ACCESSOR]), ɵɵInheritDefinitionFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(SelectMultipleControlValueAccessor, [{ + type: Directive, + args: [{ + selector: "select[multiple][formControlName],select[multiple][formControl],select[multiple][ngModel]", + host: { + "(change)": "onChange($event.target)", + "(blur)": "onTouched()" + }, + providers: [SELECT_MULTIPLE_VALUE_ACCESSOR], + standalone: false + }] + }], null, { + compareWith: [{ + type: Input + }] + }); +})(); +var ɵNgSelectMultipleOption = class _ɵNgSelectMultipleOption { + _element; + _renderer; + _select; + id; + /** @internal */ + _value; + constructor(_element, _renderer, _select) { + this._element = _element; + this._renderer = _renderer; + this._select = _select; + if (this._select) { + this.id = this._select._registerOption(this); + } + } + /** + * @description + * Tracks the value bound to the option element. Unlike the value binding, + * ngValue supports binding to objects. + */ + set ngValue(value) { + if (this._select == null) return; + this._value = value; + this._setElementValue(_buildValueString(this.id, value)); + this._select.writeValue(this._select.value); + } + /** + * @description + * Tracks simple string values bound to the option element. + * For objects, use the `ngValue` input binding. + */ + set value(value) { + if (this._select) { + this._value = value; + this._setElementValue(_buildValueString(this.id, value)); + this._select.writeValue(this._select.value); + } else { + this._setElementValue(value); + } + } + /** @internal */ + _setElementValue(value) { + this._renderer.setProperty(this._element.nativeElement, "value", value); + } + /** @internal */ + _setSelected(selected) { + this._renderer.setProperty(this._element.nativeElement, "selected", selected); + } + /** @docs-private */ + ngOnDestroy() { + if (this._select) { + this._select._optionMap.delete(this.id); + this._select.writeValue(this._select.value); + } + } + static ɵfac = function ɵNgSelectMultipleOption_Factory(__ngFactoryType__) { + return new (__ngFactoryType__ || _ɵNgSelectMultipleOption)(ɵɵdirectiveInject(ElementRef), ɵɵdirectiveInject(Renderer2), ɵɵdirectiveInject(SelectMultipleControlValueAccessor, 9)); + }; + static ɵdir = ɵɵdefineDirective({ + type: _ɵNgSelectMultipleOption, + selectors: [["option"]], + inputs: { + ngValue: "ngValue", + value: "value" + }, + standalone: false + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ɵNgSelectMultipleOption, [{ + type: Directive, + args: [{ + selector: "option", + standalone: false + }] + }], () => [{ + type: ElementRef + }, { + type: Renderer2 + }, { + type: SelectMultipleControlValueAccessor, + decorators: [{ + type: Optional + }, { + type: Host + }] + }], { + ngValue: [{ + type: Input, + args: ["ngValue"] + }], + value: [{ + type: Input, + args: ["value"] + }] + }); +})(); +function toInteger(value) { + return typeof value === "number" ? value : parseInt(value, 10); +} +function toFloat(value) { + return typeof value === "number" ? value : parseFloat(value); +} +var AbstractValidatorDirective = class _AbstractValidatorDirective { + _validator = nullValidator; + _onChange; + /** + * A flag that tracks whether this validator is enabled. + * + * Marking it `internal` (vs `protected`), so that this flag can be used in host bindings of + * directive classes that extend this base class. + * @internal + */ + _enabled; + /** @docs-private */ + ngOnChanges(changes) { + if (this.inputName in changes) { + const input = this.normalizeInput(changes[this.inputName].currentValue); + this._enabled = this.enabled(input); + this._validator = this._enabled ? this.createValidator(input) : nullValidator; + if (this._onChange) { + this._onChange(); + } + } + } + /** @docs-private */ + validate(control) { + return this._validator(control); + } + /** @docs-private */ + registerOnValidatorChange(fn) { + this._onChange = fn; + } + /** + * @description + * Determines whether this validator should be active or not based on an input. + * Base class implementation checks whether an input is defined (if the value is different from + * `null` and `undefined`). Validator classes that extend this base class can override this + * function with the logic specific to a particular validator directive. + */ + enabled(input) { + return input != null; + } + static ɵfac = function AbstractValidatorDirective_Factory(__ngFactoryType__) { + return new (__ngFactoryType__ || _AbstractValidatorDirective)(); + }; + static ɵdir = ɵɵdefineDirective({ + type: _AbstractValidatorDirective, + features: [ɵɵNgOnChangesFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(AbstractValidatorDirective, [{ + type: Directive + }], null, null); +})(); +var MAX_VALIDATOR = { + provide: NG_VALIDATORS, + useExisting: forwardRef(() => MaxValidator), + multi: true +}; +var MaxValidator = class _MaxValidator extends AbstractValidatorDirective { + /** + * @description + * Tracks changes to the max bound to this directive. + */ + max; + /** @internal */ + inputName = "max"; + /** @internal */ + normalizeInput = (input) => toFloat(input); + /** @internal */ + createValidator = (max) => maxValidator(max); + static ɵfac = /* @__PURE__ */ (() => { + let ɵMaxValidator_BaseFactory; + return function MaxValidator_Factory(__ngFactoryType__) { + return (ɵMaxValidator_BaseFactory || (ɵMaxValidator_BaseFactory = ɵɵgetInheritedFactory(_MaxValidator)))(__ngFactoryType__ || _MaxValidator); + }; + })(); + static ɵdir = ɵɵdefineDirective({ + type: _MaxValidator, + selectors: [["input", "type", "number", "max", "", "formControlName", ""], ["input", "type", "number", "max", "", "formControl", ""], ["input", "type", "number", "max", "", "ngModel", ""]], + hostVars: 1, + hostBindings: function MaxValidator_HostBindings(rf, ctx) { + if (rf & 2) { + ɵɵattribute("max", ctx._enabled ? ctx.max : null); + } + }, + inputs: { + max: "max" + }, + standalone: false, + features: [ɵɵProvidersFeature([MAX_VALIDATOR]), ɵɵInheritDefinitionFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(MaxValidator, [{ + type: Directive, + args: [{ + selector: "input[type=number][max][formControlName],input[type=number][max][formControl],input[type=number][max][ngModel]", + providers: [MAX_VALIDATOR], + host: { + "[attr.max]": "_enabled ? max : null" + }, + standalone: false + }] + }], null, { + max: [{ + type: Input + }] + }); +})(); +var MIN_VALIDATOR = { + provide: NG_VALIDATORS, + useExisting: forwardRef(() => MinValidator), + multi: true +}; +var MinValidator = class _MinValidator extends AbstractValidatorDirective { + /** + * @description + * Tracks changes to the min bound to this directive. + */ + min; + /** @internal */ + inputName = "min"; + /** @internal */ + normalizeInput = (input) => toFloat(input); + /** @internal */ + createValidator = (min) => minValidator(min); + static ɵfac = /* @__PURE__ */ (() => { + let ɵMinValidator_BaseFactory; + return function MinValidator_Factory(__ngFactoryType__) { + return (ɵMinValidator_BaseFactory || (ɵMinValidator_BaseFactory = ɵɵgetInheritedFactory(_MinValidator)))(__ngFactoryType__ || _MinValidator); + }; + })(); + static ɵdir = ɵɵdefineDirective({ + type: _MinValidator, + selectors: [["input", "type", "number", "min", "", "formControlName", ""], ["input", "type", "number", "min", "", "formControl", ""], ["input", "type", "number", "min", "", "ngModel", ""]], + hostVars: 1, + hostBindings: function MinValidator_HostBindings(rf, ctx) { + if (rf & 2) { + ɵɵattribute("min", ctx._enabled ? ctx.min : null); + } + }, + inputs: { + min: "min" + }, + standalone: false, + features: [ɵɵProvidersFeature([MIN_VALIDATOR]), ɵɵInheritDefinitionFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(MinValidator, [{ + type: Directive, + args: [{ + selector: "input[type=number][min][formControlName],input[type=number][min][formControl],input[type=number][min][ngModel]", + providers: [MIN_VALIDATOR], + host: { + "[attr.min]": "_enabled ? min : null" + }, + standalone: false + }] + }], null, { + min: [{ + type: Input + }] + }); +})(); +var REQUIRED_VALIDATOR = { + provide: NG_VALIDATORS, + useExisting: forwardRef(() => RequiredValidator), + multi: true +}; +var CHECKBOX_REQUIRED_VALIDATOR = { + provide: NG_VALIDATORS, + useExisting: forwardRef(() => CheckboxRequiredValidator), + multi: true +}; +var RequiredValidator = class _RequiredValidator extends AbstractValidatorDirective { + /** + * @description + * Tracks changes to the required attribute bound to this directive. + */ + required; + /** @internal */ + inputName = "required"; + /** @internal */ + normalizeInput = booleanAttribute; + /** @internal */ + createValidator = (input) => requiredValidator; + /** @docs-private */ + enabled(input) { + return input; + } + static ɵfac = /* @__PURE__ */ (() => { + let ɵRequiredValidator_BaseFactory; + return function RequiredValidator_Factory(__ngFactoryType__) { + return (ɵRequiredValidator_BaseFactory || (ɵRequiredValidator_BaseFactory = ɵɵgetInheritedFactory(_RequiredValidator)))(__ngFactoryType__ || _RequiredValidator); + }; + })(); + static ɵdir = ɵɵdefineDirective({ + type: _RequiredValidator, + selectors: [["", "required", "", "formControlName", "", 3, "type", "checkbox"], ["", "required", "", "formControl", "", 3, "type", "checkbox"], ["", "required", "", "ngModel", "", 3, "type", "checkbox"]], + hostVars: 1, + hostBindings: function RequiredValidator_HostBindings(rf, ctx) { + if (rf & 2) { + ɵɵattribute("required", ctx._enabled ? "" : null); + } + }, + inputs: { + required: "required" + }, + standalone: false, + features: [ɵɵProvidersFeature([REQUIRED_VALIDATOR]), ɵɵInheritDefinitionFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RequiredValidator, [{ + type: Directive, + args: [{ + selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", + providers: [REQUIRED_VALIDATOR], + host: { + "[attr.required]": '_enabled ? "" : null' + }, + standalone: false + }] + }], null, { + required: [{ + type: Input + }] + }); +})(); +var CheckboxRequiredValidator = class _CheckboxRequiredValidator extends RequiredValidator { + /** @internal */ + createValidator = (input) => requiredTrueValidator; + static ɵfac = /* @__PURE__ */ (() => { + let ɵCheckboxRequiredValidator_BaseFactory; + return function CheckboxRequiredValidator_Factory(__ngFactoryType__) { + return (ɵCheckboxRequiredValidator_BaseFactory || (ɵCheckboxRequiredValidator_BaseFactory = ɵɵgetInheritedFactory(_CheckboxRequiredValidator)))(__ngFactoryType__ || _CheckboxRequiredValidator); + }; + })(); + static ɵdir = ɵɵdefineDirective({ + type: _CheckboxRequiredValidator, + selectors: [["input", "type", "checkbox", "required", "", "formControlName", ""], ["input", "type", "checkbox", "required", "", "formControl", ""], ["input", "type", "checkbox", "required", "", "ngModel", ""]], + hostVars: 1, + hostBindings: function CheckboxRequiredValidator_HostBindings(rf, ctx) { + if (rf & 2) { + ɵɵattribute("required", ctx._enabled ? "" : null); + } + }, + standalone: false, + features: [ɵɵProvidersFeature([CHECKBOX_REQUIRED_VALIDATOR]), ɵɵInheritDefinitionFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(CheckboxRequiredValidator, [{ + type: Directive, + args: [{ + selector: "input[type=checkbox][required][formControlName],input[type=checkbox][required][formControl],input[type=checkbox][required][ngModel]", + providers: [CHECKBOX_REQUIRED_VALIDATOR], + host: { + "[attr.required]": '_enabled ? "" : null' + }, + standalone: false + }] + }], null, null); +})(); +var EMAIL_VALIDATOR = { + provide: NG_VALIDATORS, + useExisting: forwardRef(() => EmailValidator), + multi: true +}; +var EmailValidator = class _EmailValidator extends AbstractValidatorDirective { + /** + * @description + * Tracks changes to the email attribute bound to this directive. + */ + email; + /** @internal */ + inputName = "email"; + /** @internal */ + normalizeInput = booleanAttribute; + /** @internal */ + createValidator = (input) => emailValidator; + /** @docs-private */ + enabled(input) { + return input; + } + static ɵfac = /* @__PURE__ */ (() => { + let ɵEmailValidator_BaseFactory; + return function EmailValidator_Factory(__ngFactoryType__) { + return (ɵEmailValidator_BaseFactory || (ɵEmailValidator_BaseFactory = ɵɵgetInheritedFactory(_EmailValidator)))(__ngFactoryType__ || _EmailValidator); + }; + })(); + static ɵdir = ɵɵdefineDirective({ + type: _EmailValidator, + selectors: [["", "email", "", "formControlName", ""], ["", "email", "", "formControl", ""], ["", "email", "", "ngModel", ""]], + inputs: { + email: "email" + }, + standalone: false, + features: [ɵɵProvidersFeature([EMAIL_VALIDATOR]), ɵɵInheritDefinitionFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(EmailValidator, [{ + type: Directive, + args: [{ + selector: "[email][formControlName],[email][formControl],[email][ngModel]", + providers: [EMAIL_VALIDATOR], + standalone: false + }] + }], null, { + email: [{ + type: Input + }] + }); +})(); +var MIN_LENGTH_VALIDATOR = { + provide: NG_VALIDATORS, + useExisting: forwardRef(() => MinLengthValidator), + multi: true +}; +var MinLengthValidator = class _MinLengthValidator extends AbstractValidatorDirective { + /** + * @description + * Tracks changes to the minimum length bound to this directive. + */ + minlength; + /** @internal */ + inputName = "minlength"; + /** @internal */ + normalizeInput = (input) => toInteger(input); + /** @internal */ + createValidator = (minlength) => minLengthValidator(minlength); + static ɵfac = /* @__PURE__ */ (() => { + let ɵMinLengthValidator_BaseFactory; + return function MinLengthValidator_Factory(__ngFactoryType__) { + return (ɵMinLengthValidator_BaseFactory || (ɵMinLengthValidator_BaseFactory = ɵɵgetInheritedFactory(_MinLengthValidator)))(__ngFactoryType__ || _MinLengthValidator); + }; + })(); + static ɵdir = ɵɵdefineDirective({ + type: _MinLengthValidator, + selectors: [["", "minlength", "", "formControlName", ""], ["", "minlength", "", "formControl", ""], ["", "minlength", "", "ngModel", ""]], + hostVars: 1, + hostBindings: function MinLengthValidator_HostBindings(rf, ctx) { + if (rf & 2) { + ɵɵattribute("minlength", ctx._enabled ? ctx.minlength : null); + } + }, + inputs: { + minlength: "minlength" + }, + standalone: false, + features: [ɵɵProvidersFeature([MIN_LENGTH_VALIDATOR]), ɵɵInheritDefinitionFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(MinLengthValidator, [{ + type: Directive, + args: [{ + selector: "[minlength][formControlName],[minlength][formControl],[minlength][ngModel]", + providers: [MIN_LENGTH_VALIDATOR], + host: { + "[attr.minlength]": "_enabled ? minlength : null" + }, + standalone: false + }] + }], null, { + minlength: [{ + type: Input + }] + }); +})(); +var MAX_LENGTH_VALIDATOR = { + provide: NG_VALIDATORS, + useExisting: forwardRef(() => MaxLengthValidator), + multi: true +}; +var MaxLengthValidator = class _MaxLengthValidator extends AbstractValidatorDirective { + /** + * @description + * Tracks changes to the maximum length bound to this directive. + */ + maxlength; + /** @internal */ + inputName = "maxlength"; + /** @internal */ + normalizeInput = (input) => toInteger(input); + /** @internal */ + createValidator = (maxlength) => maxLengthValidator(maxlength); + static ɵfac = /* @__PURE__ */ (() => { + let ɵMaxLengthValidator_BaseFactory; + return function MaxLengthValidator_Factory(__ngFactoryType__) { + return (ɵMaxLengthValidator_BaseFactory || (ɵMaxLengthValidator_BaseFactory = ɵɵgetInheritedFactory(_MaxLengthValidator)))(__ngFactoryType__ || _MaxLengthValidator); + }; + })(); + static ɵdir = ɵɵdefineDirective({ + type: _MaxLengthValidator, + selectors: [["", "maxlength", "", "formControlName", ""], ["", "maxlength", "", "formControl", ""], ["", "maxlength", "", "ngModel", ""]], + hostVars: 1, + hostBindings: function MaxLengthValidator_HostBindings(rf, ctx) { + if (rf & 2) { + ɵɵattribute("maxlength", ctx._enabled ? ctx.maxlength : null); + } + }, + inputs: { + maxlength: "maxlength" + }, + standalone: false, + features: [ɵɵProvidersFeature([MAX_LENGTH_VALIDATOR]), ɵɵInheritDefinitionFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(MaxLengthValidator, [{ + type: Directive, + args: [{ + selector: "[maxlength][formControlName],[maxlength][formControl],[maxlength][ngModel]", + providers: [MAX_LENGTH_VALIDATOR], + host: { + "[attr.maxlength]": "_enabled ? maxlength : null" + }, + standalone: false + }] + }], null, { + maxlength: [{ + type: Input + }] + }); +})(); +var PATTERN_VALIDATOR = { + provide: NG_VALIDATORS, + useExisting: forwardRef(() => PatternValidator), + multi: true +}; +var PatternValidator = class _PatternValidator extends AbstractValidatorDirective { + /** + * @description + * Tracks changes to the pattern bound to this directive. + */ + pattern; + // This input is always defined, since the name matches selector. + /** @internal */ + inputName = "pattern"; + /** @internal */ + normalizeInput = (input) => input; + /** @internal */ + createValidator = (input) => patternValidator(input); + static ɵfac = /* @__PURE__ */ (() => { + let ɵPatternValidator_BaseFactory; + return function PatternValidator_Factory(__ngFactoryType__) { + return (ɵPatternValidator_BaseFactory || (ɵPatternValidator_BaseFactory = ɵɵgetInheritedFactory(_PatternValidator)))(__ngFactoryType__ || _PatternValidator); + }; + })(); + static ɵdir = ɵɵdefineDirective({ + type: _PatternValidator, + selectors: [["", "pattern", "", "formControlName", ""], ["", "pattern", "", "formControl", ""], ["", "pattern", "", "ngModel", ""]], + hostVars: 1, + hostBindings: function PatternValidator_HostBindings(rf, ctx) { + if (rf & 2) { + ɵɵattribute("pattern", ctx._enabled ? ctx.pattern : null); + } + }, + inputs: { + pattern: "pattern" + }, + standalone: false, + features: [ɵɵProvidersFeature([PATTERN_VALIDATOR]), ɵɵInheritDefinitionFeature] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PatternValidator, [{ + type: Directive, + args: [{ + selector: "[pattern][formControlName],[pattern][formControl],[pattern][ngModel]", + providers: [PATTERN_VALIDATOR], + host: { + "[attr.pattern]": "_enabled ? pattern : null" + }, + standalone: false + }] + }], null, { + pattern: [{ + type: Input + }] + }); +})(); +var SHARED_FORM_DIRECTIVES = [ɵNgNoValidate, NgSelectOption, ɵNgSelectMultipleOption, DefaultValueAccessor, NumberValueAccessor, RangeValueAccessor, CheckboxControlValueAccessor, SelectControlValueAccessor, SelectMultipleControlValueAccessor, RadioControlValueAccessor, NgControlStatus, NgControlStatusGroup, RequiredValidator, MinLengthValidator, MaxLengthValidator, PatternValidator, CheckboxRequiredValidator, EmailValidator, MinValidator, MaxValidator]; +var TEMPLATE_DRIVEN_DIRECTIVES = [NgModel, NgModelGroup, NgForm]; +var REACTIVE_DRIVEN_DIRECTIVES = [FormControlDirective, FormGroupDirective, FormControlName, FormGroupName, FormArrayName]; +var ɵInternalFormsSharedModule = class _ɵInternalFormsSharedModule { + static ɵfac = function ɵInternalFormsSharedModule_Factory(__ngFactoryType__) { + return new (__ngFactoryType__ || _ɵInternalFormsSharedModule)(); + }; + static ɵmod = ɵɵdefineNgModule({ + type: _ɵInternalFormsSharedModule, + declarations: [ɵNgNoValidate, NgSelectOption, ɵNgSelectMultipleOption, DefaultValueAccessor, NumberValueAccessor, RangeValueAccessor, CheckboxControlValueAccessor, SelectControlValueAccessor, SelectMultipleControlValueAccessor, RadioControlValueAccessor, NgControlStatus, NgControlStatusGroup, RequiredValidator, MinLengthValidator, MaxLengthValidator, PatternValidator, CheckboxRequiredValidator, EmailValidator, MinValidator, MaxValidator], + exports: [ɵNgNoValidate, NgSelectOption, ɵNgSelectMultipleOption, DefaultValueAccessor, NumberValueAccessor, RangeValueAccessor, CheckboxControlValueAccessor, SelectControlValueAccessor, SelectMultipleControlValueAccessor, RadioControlValueAccessor, NgControlStatus, NgControlStatusGroup, RequiredValidator, MinLengthValidator, MaxLengthValidator, PatternValidator, CheckboxRequiredValidator, EmailValidator, MinValidator, MaxValidator] + }); + static ɵinj = ɵɵdefineInjector({}); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ɵInternalFormsSharedModule, [{ + type: NgModule, + args: [{ + declarations: SHARED_FORM_DIRECTIVES, + exports: SHARED_FORM_DIRECTIVES + }] + }], null, null); +})(); +var FormArray = class extends AbstractControl { + /** + * Creates a new `FormArray` instance. + * + * @param controls An array of child controls. Each child control is given an index + * where it is registered. + * + * @param validatorOrOpts A synchronous validator function, or an array of + * such functions, or an `AbstractControlOptions` object that contains validation functions + * and a validation trigger. + * + * @param asyncValidator A single async validator or array of async validator functions + * + */ + constructor(controls, validatorOrOpts, asyncValidator) { + super(pickValidators(validatorOrOpts), pickAsyncValidators(asyncValidator, validatorOrOpts)); + this.controls = controls; + this._initObservables(); + this._setUpdateStrategy(validatorOrOpts); + this._setUpControls(); + this.updateValueAndValidity({ + onlySelf: true, + // If `asyncValidator` is present, it will trigger control status change from `PENDING` to + // `VALID` or `INVALID`. + // The status should be broadcasted via the `statusChanges` observable, so we set `emitEvent` + // to `true` to allow that during the control creation process. + emitEvent: !!this.asyncValidator + }); + } + controls; + /** + * Get the `AbstractControl` at the given `index` in the array. + * + * @param index Index in the array to retrieve the control. If `index` is negative, it will wrap + * around from the back, and if index is greatly negative (less than `-length`), the result is + * undefined. This behavior is the same as `Array.at(index)`. + */ + at(index) { + return this.controls[this._adjustIndex(index)]; + } + /** + * Insert a new `AbstractControl` at the end of the array. + * + * @param control Form control to be inserted + * @param options Specifies whether this FormArray instance should emit events after a new + * control is added. + * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and + * `valueChanges` observables emit events with the latest status and value when the control is + * inserted. When false, no events are emitted. + */ + push(control, options = {}) { + this.controls.push(control); + this._registerControl(control); + this.updateValueAndValidity({ + emitEvent: options.emitEvent + }); + this._onCollectionChange(); + } + /** + * Insert a new `AbstractControl` at the given `index` in the array. + * + * @param index Index in the array to insert the control. If `index` is negative, wraps around + * from the back. If `index` is greatly negative (less than `-length`), prepends to the array. + * This behavior is the same as `Array.splice(index, 0, control)`. + * @param control Form control to be inserted + * @param options Specifies whether this FormArray instance should emit events after a new + * control is inserted. + * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and + * `valueChanges` observables emit events with the latest status and value when the control is + * inserted. When false, no events are emitted. + */ + insert(index, control, options = {}) { + this.controls.splice(index, 0, control); + this._registerControl(control); + this.updateValueAndValidity({ + emitEvent: options.emitEvent + }); + } + /** + * Remove the control at the given `index` in the array. + * + * @param index Index in the array to remove the control. If `index` is negative, wraps around + * from the back. If `index` is greatly negative (less than `-length`), removes the first + * element. This behavior is the same as `Array.splice(index, 1)`. + * @param options Specifies whether this FormArray instance should emit events after a + * control is removed. + * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and + * `valueChanges` observables emit events with the latest status and value when the control is + * removed. When false, no events are emitted. + */ + removeAt(index, options = {}) { + let adjustedIndex = this._adjustIndex(index); + if (adjustedIndex < 0) adjustedIndex = 0; + if (this.controls[adjustedIndex]) this.controls[adjustedIndex]._registerOnCollectionChange(() => { + }); + this.controls.splice(adjustedIndex, 1); + this.updateValueAndValidity({ + emitEvent: options.emitEvent + }); + } + /** + * Replace an existing control. + * + * @param index Index in the array to replace the control. If `index` is negative, wraps around + * from the back. If `index` is greatly negative (less than `-length`), replaces the first + * element. This behavior is the same as `Array.splice(index, 1, control)`. + * @param control The `AbstractControl` control to replace the existing control + * @param options Specifies whether this FormArray instance should emit events after an + * existing control is replaced with a new one. + * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and + * `valueChanges` observables emit events with the latest status and value when the control is + * replaced with a new one. When false, no events are emitted. + */ + setControl(index, control, options = {}) { + let adjustedIndex = this._adjustIndex(index); + if (adjustedIndex < 0) adjustedIndex = 0; + if (this.controls[adjustedIndex]) this.controls[adjustedIndex]._registerOnCollectionChange(() => { + }); + this.controls.splice(adjustedIndex, 1); + if (control) { + this.controls.splice(adjustedIndex, 0, control); + this._registerControl(control); + } + this.updateValueAndValidity({ + emitEvent: options.emitEvent + }); + this._onCollectionChange(); + } + /** + * Length of the control array. + */ + get length() { + return this.controls.length; + } + /** + * Sets the value of the `FormArray`. It accepts an array that matches + * the structure of the control. + * + * This method performs strict checks, and throws an error if you try + * to set the value of a control that doesn't exist or if you exclude the + * value of a control. + * + * @usageNotes + * ### Set the values for the controls in the form array + * + * ```ts + * const arr = new FormArray([ + * new FormControl(), + * new FormControl() + * ]); + * console.log(arr.value); // [null, null] + * + * arr.setValue(['Nancy', 'Drew']); + * console.log(arr.value); // ['Nancy', 'Drew'] + * ``` + * + * @param value Array of values for the controls + * @param options Configure options that determine how the control propagates changes and + * emits events after the value changes + * + * * `onlySelf`: When true, each change only affects this control, and not its parent. Default + * is false. + * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and + * `valueChanges` + * observables emit events with the latest status and value when the control value is updated. + * When false, no events are emitted. + * The configuration options are passed to the {@link AbstractControl#updateValueAndValidity + * updateValueAndValidity} method. + */ + setValue(value, options = {}) { + assertAllValuesPresent(this, false, value); + value.forEach((newValue, index) => { + assertControlPresent(this, false, index); + this.at(index).setValue(newValue, { + onlySelf: true, + emitEvent: options.emitEvent + }); + }); + this.updateValueAndValidity(options); + } + /** + * Patches the value of the `FormArray`. It accepts an array that matches the + * structure of the control, and does its best to match the values to the correct + * controls in the group. + * + * It accepts both super-sets and sub-sets of the array without throwing an error. + * + * @usageNotes + * ### Patch the values for controls in a form array + * + * ```ts + * const arr = new FormArray([ + * new FormControl(), + * new FormControl() + * ]); + * console.log(arr.value); // [null, null] + * + * arr.patchValue(['Nancy']); + * console.log(arr.value); // ['Nancy', null] + * ``` + * + * @param value Array of latest values for the controls + * @param options Configure options that determine how the control propagates changes and + * emits events after the value changes + * + * * `onlySelf`: When true, each change only affects this control, and not its parent. Default + * is false. + * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and + * `valueChanges` observables emit events with the latest status and value when the control + * value is updated. When false, no events are emitted. The configuration options are passed to + * the {@link AbstractControl#updateValueAndValidity updateValueAndValidity} method. + */ + patchValue(value, options = {}) { + if (value == null) return; + value.forEach((newValue, index) => { + if (this.at(index)) { + this.at(index).patchValue(newValue, { + onlySelf: true, + emitEvent: options.emitEvent + }); + } + }); + this.updateValueAndValidity(options); + } + /** + * Resets the `FormArray` and all descendants are marked `pristine` and `untouched`, and the + * value of all descendants to null or null maps. + * + * You reset to a specific form state by passing in an array of states + * that matches the structure of the control. The state is a standalone value + * or a form state object with both a value and a disabled status. + * + * @usageNotes + * ### Reset the values in a form array + * + * ```ts + * const arr = new FormArray([ + * new FormControl(), + * new FormControl() + * ]); + * arr.reset(['name', 'last name']); + * + * console.log(arr.value); // ['name', 'last name'] + * ``` + * + * ### Reset the values in a form array and the disabled status for the first control + * + * ```ts + * arr.reset([ + * {value: 'name', disabled: true}, + * 'last' + * ]); + * + * console.log(arr.value); // ['last'] + * console.log(arr.at(0).status); // 'DISABLED' + * ``` + * + * @param value Array of values for the controls + * @param options Configure options that determine how the control propagates changes and + * emits events after the value changes + * + * * `onlySelf`: When true, each change only affects this control, and not its parent. Default + * is false. + * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and + * `valueChanges` + * observables emit events with the latest status and value when the control is reset. + * When false, no events are emitted. + * The configuration options are passed to the {@link AbstractControl#updateValueAndValidity + * updateValueAndValidity} method. + */ + reset(value = [], options = {}) { + this._forEachChild((control, index) => { + control.reset(value[index], { + onlySelf: true, + emitEvent: options.emitEvent + }); + }); + this._updatePristine(options, this); + this._updateTouched(options, this); + this.updateValueAndValidity(options); + } + /** + * The aggregate value of the array, including any disabled controls. + * + * Reports all values regardless of disabled status. + */ + getRawValue() { + return this.controls.map((control) => control.getRawValue()); + } + /** + * Remove all controls in the `FormArray`. + * + * @param options Specifies whether this FormArray instance should emit events after all + * controls are removed. + * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and + * `valueChanges` observables emit events with the latest status and value when all controls + * in this FormArray instance are removed. When false, no events are emitted. + * + * @usageNotes + * ### Remove all elements from a FormArray + * + * ```ts + * const arr = new FormArray([ + * new FormControl(), + * new FormControl() + * ]); + * console.log(arr.length); // 2 + * + * arr.clear(); + * console.log(arr.length); // 0 + * ``` + * + * It's a simpler and more efficient alternative to removing all elements one by one: + * + * ```ts + * const arr = new FormArray([ + * new FormControl(), + * new FormControl() + * ]); + * + * while (arr.length) { + * arr.removeAt(0); + * } + * ``` + */ + clear(options = {}) { + if (this.controls.length < 1) return; + this._forEachChild((control) => control._registerOnCollectionChange(() => { + })); + this.controls.splice(0); + this.updateValueAndValidity({ + emitEvent: options.emitEvent + }); + } + /** + * Adjusts a negative index by summing it with the length of the array. For very negative + * indices, the result may remain negative. + * @internal + */ + _adjustIndex(index) { + return index < 0 ? index + this.length : index; + } + /** @internal */ + _syncPendingControls() { + let subtreeUpdated = this.controls.reduce((updated, child) => { + return child._syncPendingControls() ? true : updated; + }, false); + if (subtreeUpdated) this.updateValueAndValidity({ + onlySelf: true + }); + return subtreeUpdated; + } + /** @internal */ + _forEachChild(cb) { + this.controls.forEach((control, index) => { + cb(control, index); + }); + } + /** @internal */ + _updateValue() { + this.value = this.controls.filter((control) => control.enabled || this.disabled).map((control) => control.value); + } + /** @internal */ + _anyControls(condition) { + return this.controls.some((control) => control.enabled && condition(control)); + } + /** @internal */ + _setUpControls() { + this._forEachChild((control) => this._registerControl(control)); + } + /** @internal */ + _allControlsDisabled() { + for (const control of this.controls) { + if (control.enabled) return false; + } + return this.controls.length > 0 || this.disabled; + } + _registerControl(control) { + control.setParent(this); + control._registerOnCollectionChange(this._onCollectionChange); + } + /** @internal */ + _find(name) { + return this.at(name) ?? null; + } +}; +var UntypedFormArray = FormArray; +var isFormArray = (control) => control instanceof FormArray; +function isAbstractControlOptions(options) { + return !!options && (options.asyncValidators !== void 0 || options.validators !== void 0 || options.updateOn !== void 0); +} +var FormBuilder = class _FormBuilder { + useNonNullable = false; + /** + * @description + * Returns a FormBuilder in which automatically constructed `FormControl` elements + * have `{nonNullable: true}` and are non-nullable. + * + * **Constructing non-nullable controls** + * + * When constructing a control, it will be non-nullable, and will reset to its initial value. + * + * ```ts + * let nnfb = new FormBuilder().nonNullable; + * let name = nnfb.control('Alex'); // FormControl + * name.reset(); + * console.log(name); // 'Alex' + * ``` + * + * **Constructing non-nullable groups or arrays** + * + * When constructing a group or array, all automatically created inner controls will be + * non-nullable, and will reset to their initial values. + * + * ```ts + * let nnfb = new FormBuilder().nonNullable; + * let name = nnfb.group({who: 'Alex'}); // FormGroup<{who: FormControl}> + * name.reset(); + * console.log(name); // {who: 'Alex'} + * ``` + * **Constructing *nullable* fields on groups or arrays** + * + * It is still possible to have a nullable field. In particular, any `FormControl` which is + * *already* constructed will not be altered. For example: + * + * ```ts + * let nnfb = new FormBuilder().nonNullable; + * // FormGroup<{who: FormControl}> + * let name = nnfb.group({who: new FormControl('Alex')}); + * name.reset(); console.log(name); // {who: null} + * ``` + * + * Because the inner control is constructed explicitly by the caller, the builder has + * no control over how it is created, and cannot exclude the `null`. + */ + get nonNullable() { + const nnfb = new _FormBuilder(); + nnfb.useNonNullable = true; + return nnfb; + } + group(controls, options = null) { + const reducedControls = this._reduceControls(controls); + let newOptions = {}; + if (isAbstractControlOptions(options)) { + newOptions = options; + } else if (options !== null) { + newOptions.validators = options.validator; + newOptions.asyncValidators = options.asyncValidator; + } + return new FormGroup(reducedControls, newOptions); + } + /** + * @description + * Constructs a new `FormRecord` instance. Accepts a single generic argument, which is an object + * containing all the keys and corresponding inner control types. + * + * @param controls A collection of child controls. The key for each child is the name + * under which it is registered. + * + * @param options Configuration options object for the `FormRecord`. The object should have the + * `AbstractControlOptions` type and might contain the following fields: + * * `validators`: A synchronous validator function, or an array of validator functions. + * * `asyncValidators`: A single async validator or array of async validator functions. + * * `updateOn`: The event upon which the control should be updated (options: 'change' | 'blur' + * | submit'). + */ + record(controls, options = null) { + const reducedControls = this._reduceControls(controls); + return new FormRecord(reducedControls, options); + } + /** + * @description + * Constructs a new `FormControl` with the given state, validators and options. Sets + * `{nonNullable: true}` in the options to get a non-nullable control. Otherwise, the + * control will be nullable. Accepts a single generic argument, which is the type of the + * control's value. + * + * @param formState Initializes the control with an initial state value, or + * with an object that contains both a value and a disabled status. + * + * @param validatorOrOpts A synchronous validator function, or an array of + * such functions, or a `FormControlOptions` object that contains + * validation functions and a validation trigger. + * + * @param asyncValidator A single async validator or array of async validator + * functions. + * + * @usageNotes + * + * ### Initialize a control as disabled + * + * The following example returns a control with an initial value in a disabled state. + * + * {@example forms/ts/formBuilder/form_builder_example.ts region='disabled-control'} + */ + control(formState, validatorOrOpts, asyncValidator) { + let newOptions = {}; + if (!this.useNonNullable) { + return new FormControl(formState, validatorOrOpts, asyncValidator); + } + if (isAbstractControlOptions(validatorOrOpts)) { + newOptions = validatorOrOpts; + } else { + newOptions.validators = validatorOrOpts; + newOptions.asyncValidators = asyncValidator; + } + return new FormControl(formState, __spreadProps(__spreadValues({}, newOptions), { + nonNullable: true + })); + } + /** + * Constructs a new `FormArray` from the given array of configurations, + * validators and options. Accepts a single generic argument, which is the type of each control + * inside the array. + * + * @param controls An array of child controls or control configs. Each child control is given an + * index when it is registered. + * + * @param validatorOrOpts A synchronous validator function, or an array of such functions, or an + * `AbstractControlOptions` object that contains + * validation functions and a validation trigger. + * + * @param asyncValidator A single async validator or array of async validator functions. + */ + array(controls, validatorOrOpts, asyncValidator) { + const createdControls = controls.map((c) => this._createControl(c)); + return new FormArray(createdControls, validatorOrOpts, asyncValidator); + } + /** @internal */ + _reduceControls(controls) { + const createdControls = {}; + Object.keys(controls).forEach((controlName) => { + createdControls[controlName] = this._createControl(controls[controlName]); + }); + return createdControls; + } + /** @internal */ + _createControl(controls) { + if (controls instanceof FormControl) { + return controls; + } else if (controls instanceof AbstractControl) { + return controls; + } else if (Array.isArray(controls)) { + const value = controls[0]; + const validator = controls.length > 1 ? controls[1] : null; + const asyncValidator = controls.length > 2 ? controls[2] : null; + return this.control(value, validator, asyncValidator); + } else { + return this.control(controls); + } + } + static ɵfac = function FormBuilder_Factory(__ngFactoryType__) { + return new (__ngFactoryType__ || _FormBuilder)(); + }; + static ɵprov = ɵɵdefineInjectable({ + token: _FormBuilder, + factory: _FormBuilder.ɵfac, + providedIn: "root" + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FormBuilder, [{ + type: Injectable, + args: [{ + providedIn: "root" + }] + }], null, null); +})(); +var NonNullableFormBuilder = class _NonNullableFormBuilder { + static ɵfac = function NonNullableFormBuilder_Factory(__ngFactoryType__) { + return new (__ngFactoryType__ || _NonNullableFormBuilder)(); + }; + static ɵprov = ɵɵdefineInjectable({ + token: _NonNullableFormBuilder, + factory: () => (() => inject(FormBuilder).nonNullable)(), + providedIn: "root" + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NonNullableFormBuilder, [{ + type: Injectable, + args: [{ + providedIn: "root", + useFactory: () => inject(FormBuilder).nonNullable + }] + }], null, null); +})(); +var UntypedFormBuilder = class _UntypedFormBuilder extends FormBuilder { + group(controlsConfig, options = null) { + return super.group(controlsConfig, options); + } + /** + * Like `FormBuilder#control`, except the resulting control is untyped. + */ + control(formState, validatorOrOpts, asyncValidator) { + return super.control(formState, validatorOrOpts, asyncValidator); + } + /** + * Like `FormBuilder#array`, except the resulting array is untyped. + */ + array(controlsConfig, validatorOrOpts, asyncValidator) { + return super.array(controlsConfig, validatorOrOpts, asyncValidator); + } + static ɵfac = /* @__PURE__ */ (() => { + let ɵUntypedFormBuilder_BaseFactory; + return function UntypedFormBuilder_Factory(__ngFactoryType__) { + return (ɵUntypedFormBuilder_BaseFactory || (ɵUntypedFormBuilder_BaseFactory = ɵɵgetInheritedFactory(_UntypedFormBuilder)))(__ngFactoryType__ || _UntypedFormBuilder); + }; + })(); + static ɵprov = ɵɵdefineInjectable({ + token: _UntypedFormBuilder, + factory: _UntypedFormBuilder.ɵfac, + providedIn: "root" + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(UntypedFormBuilder, [{ + type: Injectable, + args: [{ + providedIn: "root" + }] + }], null, null); +})(); +var VERSION = new Version("20.1.7"); +var FormsModule = class _FormsModule { + /** + * @description + * Provides options for configuring the forms module. + * + * @param opts An object of configuration options + * * `callSetDisabledState` Configures whether to `always` call `setDisabledState`, which is more + * correct, or to only call it `whenDisabled`, which is the legacy behavior. + */ + static withConfig(opts) { + return { + ngModule: _FormsModule, + providers: [{ + provide: CALL_SET_DISABLED_STATE, + useValue: opts.callSetDisabledState ?? setDisabledStateDefault + }] + }; + } + static ɵfac = function FormsModule_Factory(__ngFactoryType__) { + return new (__ngFactoryType__ || _FormsModule)(); + }; + static ɵmod = ɵɵdefineNgModule({ + type: _FormsModule, + declarations: [NgModel, NgModelGroup, NgForm], + exports: [ɵInternalFormsSharedModule, NgModel, NgModelGroup, NgForm] + }); + static ɵinj = ɵɵdefineInjector({ + imports: [ɵInternalFormsSharedModule] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FormsModule, [{ + type: NgModule, + args: [{ + declarations: TEMPLATE_DRIVEN_DIRECTIVES, + exports: [ɵInternalFormsSharedModule, TEMPLATE_DRIVEN_DIRECTIVES] + }] + }], null, null); +})(); +var ReactiveFormsModule = class _ReactiveFormsModule { + /** + * @description + * Provides options for configuring the reactive forms module. + * + * @param opts An object of configuration options + * * `warnOnNgModelWithFormControl` Configures when to emit a warning when an `ngModel` + * binding is used with reactive form directives. + * * `callSetDisabledState` Configures whether to `always` call `setDisabledState`, which is more + * correct, or to only call it `whenDisabled`, which is the legacy behavior. + */ + static withConfig(opts) { + return { + ngModule: _ReactiveFormsModule, + providers: [{ + provide: NG_MODEL_WITH_FORM_CONTROL_WARNING, + useValue: opts.warnOnNgModelWithFormControl ?? "always" + }, { + provide: CALL_SET_DISABLED_STATE, + useValue: opts.callSetDisabledState ?? setDisabledStateDefault + }] + }; + } + static ɵfac = function ReactiveFormsModule_Factory(__ngFactoryType__) { + return new (__ngFactoryType__ || _ReactiveFormsModule)(); + }; + static ɵmod = ɵɵdefineNgModule({ + type: _ReactiveFormsModule, + declarations: [FormControlDirective, FormGroupDirective, FormControlName, FormGroupName, FormArrayName], + exports: [ɵInternalFormsSharedModule, FormControlDirective, FormGroupDirective, FormControlName, FormGroupName, FormArrayName] + }); + static ɵinj = ɵɵdefineInjector({ + imports: [ɵInternalFormsSharedModule] + }); +}; +(() => { + (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ReactiveFormsModule, [{ + type: NgModule, + args: [{ + declarations: [REACTIVE_DRIVEN_DIRECTIVES], + exports: [ɵInternalFormsSharedModule, REACTIVE_DRIVEN_DIRECTIVES] + }] + }], null, null); +})(); +export { + AbstractControl, + AbstractControlDirective, + AbstractFormGroupDirective, + COMPOSITION_BUFFER_MODE, + CheckboxControlValueAccessor, + CheckboxRequiredValidator, + ControlContainer, + ControlEvent, + DefaultValueAccessor, + EmailValidator, + FormArray, + FormArrayName, + FormBuilder, + FormControl, + FormControlDirective, + FormControlName, + FormGroup, + FormGroupDirective, + FormGroupName, + FormRecord, + FormResetEvent, + FormSubmittedEvent, + FormsModule, + MaxLengthValidator, + MaxValidator, + MinLengthValidator, + MinValidator, + NG_ASYNC_VALIDATORS, + NG_VALIDATORS, + NG_VALUE_ACCESSOR, + NgControl, + NgControlStatus, + NgControlStatusGroup, + NgForm, + NgModel, + NgModelGroup, + NgSelectOption, + NonNullableFormBuilder, + NumberValueAccessor, + PatternValidator, + PristineChangeEvent, + RadioControlValueAccessor, + RangeValueAccessor, + ReactiveFormsModule, + RequiredValidator, + SelectControlValueAccessor, + SelectMultipleControlValueAccessor, + StatusChangeEvent, + TouchedChangeEvent, + UntypedFormArray, + UntypedFormBuilder, + UntypedFormControl, + UntypedFormGroup, + VERSION, + Validators, + ValueChangeEvent, + isFormArray, + isFormControl, + isFormGroup, + isFormRecord, + ɵInternalFormsSharedModule, + ɵNgNoValidate, + ɵNgSelectMultipleOption +}; +/*! Bundled license information: + +@angular/forms/fesm2022/forms.mjs: + (** + * @license Angular v20.1.7 + * (c) 2010-2025 Google LLC. https://angular.io/ + * License: MIT + *) +*/ +//# sourceMappingURL=@angular_forms.js.map diff --git a/.angular/cache/20.1.6/TFTPaths/vite/deps/@angular_forms.js.map b/.angular/cache/20.1.6/TFTPaths/vite/deps/@angular_forms.js.map new file mode 100644 index 0000000..e6d5c55 --- /dev/null +++ b/.angular/cache/20.1.6/TFTPaths/vite/deps/@angular_forms.js.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": ["../../../../../../node_modules/@angular/forms/fesm2022/forms.mjs"], + "sourcesContent": ["/**\n * @license Angular v20.1.7\n * (c) 2010-2025 Google LLC. https://angular.io/\n * License: MIT\n */\n\nimport * as i0 from '@angular/core';\nimport { Directive, InjectionToken, forwardRef, Optional, Inject, ɵisPromise as _isPromise, ɵisSubscribable as _isSubscribable, ɵRuntimeError as _RuntimeError, Self, untracked, computed, signal, EventEmitter, Input, Host, SkipSelf, booleanAttribute, ChangeDetectorRef, Output, Injectable, inject, ApplicationRef, DestroyRef, afterNextRender, NgModule, Version } from '@angular/core';\nimport { ɵgetDOM as _getDOM } from '@angular/common';\nimport { forkJoin, from, Subject } from 'rxjs';\nimport { map } from 'rxjs/operators';\n\n/**\n * Base class for all ControlValueAccessor classes defined in Forms package.\n * Contains common logic and utility functions.\n *\n * Note: this is an *internal-only* class and should not be extended or used directly in\n * applications code.\n */\nclass BaseControlValueAccessor {\n _renderer;\n _elementRef;\n /**\n * The registered callback function called when a change or input event occurs on the input\n * element.\n * @docs-private\n */\n onChange = _ => {};\n /**\n * The registered callback function called when a blur event occurs on the input element.\n * @docs-private\n */\n onTouched = () => {};\n constructor(_renderer, _elementRef) {\n this._renderer = _renderer;\n this._elementRef = _elementRef;\n }\n /**\n * Helper method that sets a property on a target element using the current Renderer\n * implementation.\n * @docs-private\n */\n setProperty(key, value) {\n this._renderer.setProperty(this._elementRef.nativeElement, key, value);\n }\n /**\n * Registers a function called when the control is touched.\n * @docs-private\n */\n registerOnTouched(fn) {\n this.onTouched = fn;\n }\n /**\n * Registers a function called when the control value changes.\n * @docs-private\n */\n registerOnChange(fn) {\n this.onChange = fn;\n }\n /**\n * Sets the \"disabled\" property on the range input element.\n * @docs-private\n */\n setDisabledState(isDisabled) {\n this.setProperty('disabled', isDisabled);\n }\n static ɵfac = function BaseControlValueAccessor_Factory(__ngFactoryType__) {\n return new (__ngFactoryType__ || BaseControlValueAccessor)(i0.ɵɵdirectiveInject(i0.Renderer2), i0.ɵɵdirectiveInject(i0.ElementRef));\n };\n static ɵdir = /* @__PURE__ */i0.ɵɵdefineDirective({\n type: BaseControlValueAccessor\n });\n}\n(() => {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && i0.ɵsetClassMetadata(BaseControlValueAccessor, [{\n type: Directive\n }], () => [{\n type: i0.Renderer2\n }, {\n type: i0.ElementRef\n }], null);\n})();\n/**\n * Base class for all built-in ControlValueAccessor classes (except DefaultValueAccessor, which is\n * used in case no other CVAs can be found). We use this class to distinguish between default CVA,\n * built-in CVAs and custom CVAs, so that Forms logic can recognize built-in CVAs and treat custom\n * ones with higher priority (when both built-in and custom CVAs are present).\n *\n * Note: this is an *internal-only* class and should not be extended or used directly in\n * applications code.\n */\nclass BuiltInControlValueAccessor extends BaseControlValueAccessor {\n static ɵfac = /* @__PURE__ */(() => {\n let ɵBuiltInControlValueAccessor_BaseFactory;\n return function BuiltInControlValueAccessor_Factory(__ngFactoryType__) {\n return (ɵBuiltInControlValueAccessor_BaseFactory || (ɵBuiltInControlValueAccessor_BaseFactory = i0.ɵɵgetInheritedFactory(BuiltInControlValueAccessor)))(__ngFactoryType__ || BuiltInControlValueAccessor);\n };\n })();\n static ɵdir = /* @__PURE__ */i0.ɵɵdefineDirective({\n type: BuiltInControlValueAccessor,\n features: [i0.ɵɵInheritDefinitionFeature]\n });\n}\n(() => {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && i0.ɵsetClassMetadata(BuiltInControlValueAccessor, [{\n type: Directive\n }], null, null);\n})();\n/**\n * Used to provide a `ControlValueAccessor` for form controls.\n *\n * See `DefaultValueAccessor` for how to implement one.\n *\n * @publicApi\n */\nconst NG_VALUE_ACCESSOR = new InjectionToken(ngDevMode ? 'NgValueAccessor' : '');\nconst CHECKBOX_VALUE_ACCESSOR = {\n provide: NG_VALUE_ACCESSOR,\n useExisting: forwardRef(() => CheckboxControlValueAccessor),\n multi: true\n};\n/**\n * @description\n * A `ControlValueAccessor` for writing a value and listening to changes on a checkbox input\n * element.\n *\n * @usageNotes\n *\n * ### Using a checkbox with a reactive form.\n *\n * The following example shows how to use a checkbox with a reactive form.\n *\n * ```ts\n * const rememberLoginControl = new FormControl();\n * ```\n *\n * ```html\n * \n * ```\n *\n * @ngModule ReactiveFormsModule\n * @ngModule FormsModule\n * @publicApi\n */\nclass CheckboxControlValueAccessor extends BuiltInControlValueAccessor {\n /**\n * Sets the \"checked\" property on the input element.\n * @docs-private\n */\n writeValue(value) {\n this.setProperty('checked', value);\n }\n static ɵfac = /* @__PURE__ */(() => {\n let ɵCheckboxControlValueAccessor_BaseFactory;\n return function CheckboxControlValueAccessor_Factory(__ngFactoryType__) {\n return (ɵCheckboxControlValueAccessor_BaseFactory || (ɵCheckboxControlValueAccessor_BaseFactory = i0.ɵɵgetInheritedFactory(CheckboxControlValueAccessor)))(__ngFactoryType__ || CheckboxControlValueAccessor);\n };\n })();\n static ɵdir = /* @__PURE__ */i0.ɵɵdefineDirective({\n type: CheckboxControlValueAccessor,\n selectors: [[\"input\", \"type\", \"checkbox\", \"formControlName\", \"\"], [\"input\", \"type\", \"checkbox\", \"formControl\", \"\"], [\"input\", \"type\", \"checkbox\", \"ngModel\", \"\"]],\n hostBindings: function CheckboxControlValueAccessor_HostBindings(rf, ctx) {\n if (rf & 1) {\n i0.ɵɵlistener(\"change\", function CheckboxControlValueAccessor_change_HostBindingHandler($event) {\n return ctx.onChange($event.target.checked);\n })(\"blur\", function CheckboxControlValueAccessor_blur_HostBindingHandler() {\n return ctx.onTouched();\n });\n }\n },\n standalone: false,\n features: [i0.ɵɵProvidersFeature([CHECKBOX_VALUE_ACCESSOR]), i0.ɵɵInheritDefinitionFeature]\n });\n}\n(() => {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && i0.ɵsetClassMetadata(CheckboxControlValueAccessor, [{\n type: Directive,\n args: [{\n selector: 'input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]',\n host: {\n '(change)': 'onChange($any($event.target).checked)',\n '(blur)': 'onTouched()'\n },\n providers: [CHECKBOX_VALUE_ACCESSOR],\n standalone: false\n }]\n }], null, null);\n})();\nconst DEFAULT_VALUE_ACCESSOR = {\n provide: NG_VALUE_ACCESSOR,\n useExisting: forwardRef(() => DefaultValueAccessor),\n multi: true\n};\n/**\n * We must check whether the agent is Android because composition events\n * behave differently between iOS and Android.\n */\nfunction _isAndroid() {\n const userAgent = _getDOM() ? _getDOM().getUserAgent() : '';\n return /android (\\d+)/.test(userAgent.toLowerCase());\n}\n/**\n * @description\n * Provide this token to control if form directives buffer IME input until\n * the \"compositionend\" event occurs.\n * @publicApi\n */\nconst COMPOSITION_BUFFER_MODE = new InjectionToken(ngDevMode ? 'CompositionEventMode' : '');\n/**\n * The default `ControlValueAccessor` for writing a value and listening to changes on input\n * elements. The accessor is used by the `FormControlDirective`, `FormControlName`, and\n * `NgModel` directives.\n *\n *\n * @usageNotes\n *\n * ### Using the default value accessor\n *\n * The following example shows how to use an input element that activates the default value accessor\n * (in this case, a text field).\n *\n * ```ts\n * const firstNameControl = new FormControl();\n * ```\n *\n * ```html\n * \n * ```\n *\n * This value accessor is used by default for `` and `