Compare commits
16 Commits
0fd0e3bada
...
main
| Author | SHA1 | Date | |
|---|---|---|---|
d0164640a1
|
|||
|
ae5305f3c6
|
|||
|
31c0757780
|
|||
|
696729d2c2
|
|||
|
bdea643256
|
|||
|
4e5dfd7134
|
|||
|
955acc6c96
|
|||
|
c7a6d6880c
|
|||
|
400644e079
|
|||
|
f6a9dd97ed
|
|||
|
806d735c35
|
|||
|
637991c394
|
|||
|
afa4c8a684
|
|||
|
75219bc716
|
|||
|
c98e462142
|
|||
|
9af08e71fc
|
263
package-lock.json
generated
263
package-lock.json
generated
@@ -9,16 +9,15 @@
|
||||
"version": "1.0.0",
|
||||
"license": "ISC",
|
||||
"devDependencies": {
|
||||
"@types/node": "^22.15.21",
|
||||
"esbuild": "^0.25.4",
|
||||
"@types/node": "^25.5.0",
|
||||
"tsx": "^4.19.4",
|
||||
"typescript": "^5.8.3"
|
||||
"typescript": "^6.0.2"
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/aix-ppc64": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.4.tgz",
|
||||
"integrity": "sha512-1VCICWypeQKhVbE9oW/sJaAmjLxhVqacdkvPLEjwlttjfwENRSClS8EjBz0KzRyFSCPDIkuXW34Je/vk7zdB7Q==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.7.tgz",
|
||||
"integrity": "sha512-EKX3Qwmhz1eMdEJokhALr0YiD0lhQNwDqkPYyPhiSwKrh7/4KRjQc04sZ8db+5DVVnZ1LmbNDI1uAMPEUBnQPg==",
|
||||
"cpu": [
|
||||
"ppc64"
|
||||
],
|
||||
@@ -33,9 +32,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/android-arm": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.4.tgz",
|
||||
"integrity": "sha512-QNdQEps7DfFwE3hXiU4BZeOV68HHzYwGd0Nthhd3uCkkEKK7/R6MTgM0P7H7FAs5pU/DIWsviMmEGxEoxIZ+ZQ==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.7.tgz",
|
||||
"integrity": "sha512-jbPXvB4Yj2yBV7HUfE2KHe4GJX51QplCN1pGbYjvsyCZbQmies29EoJbkEc+vYuU5o45AfQn37vZlyXy4YJ8RQ==",
|
||||
"cpu": [
|
||||
"arm"
|
||||
],
|
||||
@@ -50,9 +49,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/android-arm64": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.4.tgz",
|
||||
"integrity": "sha512-bBy69pgfhMGtCnwpC/x5QhfxAz/cBgQ9enbtwjf6V9lnPI/hMyT9iWpR1arm0l3kttTr4L0KSLpKmLp/ilKS9A==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.7.tgz",
|
||||
"integrity": "sha512-62dPZHpIXzvChfvfLJow3q5dDtiNMkwiRzPylSCfriLvZeq0a1bWChrGx/BbUbPwOrsWKMn8idSllklzBy+dgQ==",
|
||||
"cpu": [
|
||||
"arm64"
|
||||
],
|
||||
@@ -67,9 +66,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/android-x64": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.4.tgz",
|
||||
"integrity": "sha512-TVhdVtQIFuVpIIR282btcGC2oGQoSfZfmBdTip2anCaVYcqWlZXGcdcKIUklfX2wj0JklNYgz39OBqh2cqXvcQ==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.7.tgz",
|
||||
"integrity": "sha512-x5VpMODneVDb70PYV2VQOmIUUiBtY3D3mPBG8NxVk5CogneYhkR7MmM3yR/uMdITLrC1ml/NV1rj4bMJuy9MCg==",
|
||||
"cpu": [
|
||||
"x64"
|
||||
],
|
||||
@@ -84,9 +83,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/darwin-arm64": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.4.tgz",
|
||||
"integrity": "sha512-Y1giCfM4nlHDWEfSckMzeWNdQS31BQGs9/rouw6Ub91tkK79aIMTH3q9xHvzH8d0wDru5Ci0kWB8b3up/nl16g==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.7.tgz",
|
||||
"integrity": "sha512-5lckdqeuBPlKUwvoCXIgI2D9/ABmPq3Rdp7IfL70393YgaASt7tbju3Ac+ePVi3KDH6N2RqePfHnXkaDtY9fkw==",
|
||||
"cpu": [
|
||||
"arm64"
|
||||
],
|
||||
@@ -101,9 +100,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/darwin-x64": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.4.tgz",
|
||||
"integrity": "sha512-CJsry8ZGM5VFVeyUYB3cdKpd/H69PYez4eJh1W/t38vzutdjEjtP7hB6eLKBoOdxcAlCtEYHzQ/PJ/oU9I4u0A==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.7.tgz",
|
||||
"integrity": "sha512-rYnXrKcXuT7Z+WL5K980jVFdvVKhCHhUwid+dDYQpH+qu+TefcomiMAJpIiC2EM3Rjtq0sO3StMV/+3w3MyyqQ==",
|
||||
"cpu": [
|
||||
"x64"
|
||||
],
|
||||
@@ -118,9 +117,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/freebsd-arm64": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.4.tgz",
|
||||
"integrity": "sha512-yYq+39NlTRzU2XmoPW4l5Ifpl9fqSk0nAJYM/V/WUGPEFfek1epLHJIkTQM6bBs1swApjO5nWgvr843g6TjxuQ==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.7.tgz",
|
||||
"integrity": "sha512-B48PqeCsEgOtzME2GbNM2roU29AMTuOIN91dsMO30t+Ydis3z/3Ngoj5hhnsOSSwNzS+6JppqWsuhTp6E82l2w==",
|
||||
"cpu": [
|
||||
"arm64"
|
||||
],
|
||||
@@ -135,9 +134,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/freebsd-x64": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.4.tgz",
|
||||
"integrity": "sha512-0FgvOJ6UUMflsHSPLzdfDnnBBVoCDtBTVyn/MrWloUNvq/5SFmh13l3dvgRPkDihRxb77Y17MbqbCAa2strMQQ==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.7.tgz",
|
||||
"integrity": "sha512-jOBDK5XEjA4m5IJK3bpAQF9/Lelu/Z9ZcdhTRLf4cajlB+8VEhFFRjWgfy3M1O4rO2GQ/b2dLwCUGpiF/eATNQ==",
|
||||
"cpu": [
|
||||
"x64"
|
||||
],
|
||||
@@ -152,9 +151,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/linux-arm": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.4.tgz",
|
||||
"integrity": "sha512-kro4c0P85GMfFYqW4TWOpvmF8rFShbWGnrLqlzp4X1TNWjRY3JMYUfDCtOxPKOIY8B0WC8HN51hGP4I4hz4AaQ==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.7.tgz",
|
||||
"integrity": "sha512-RkT/YXYBTSULo3+af8Ib0ykH8u2MBh57o7q/DAs3lTJlyVQkgQvlrPTnjIzzRPQyavxtPtfg0EopvDyIt0j1rA==",
|
||||
"cpu": [
|
||||
"arm"
|
||||
],
|
||||
@@ -169,9 +168,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/linux-arm64": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.4.tgz",
|
||||
"integrity": "sha512-+89UsQTfXdmjIvZS6nUnOOLoXnkUTB9hR5QAeLrQdzOSWZvNSAXAtcRDHWtqAUtAmv7ZM1WPOOeSxDzzzMogiQ==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.7.tgz",
|
||||
"integrity": "sha512-RZPHBoxXuNnPQO9rvjh5jdkRmVizktkT7TCDkDmQ0W2SwHInKCAV95GRuvdSvA7w4VMwfCjUiPwDi0ZO6Nfe9A==",
|
||||
"cpu": [
|
||||
"arm64"
|
||||
],
|
||||
@@ -186,9 +185,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/linux-ia32": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.4.tgz",
|
||||
"integrity": "sha512-yTEjoapy8UP3rv8dB0ip3AfMpRbyhSN3+hY8mo/i4QXFeDxmiYbEKp3ZRjBKcOP862Ua4b1PDfwlvbuwY7hIGQ==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.7.tgz",
|
||||
"integrity": "sha512-GA48aKNkyQDbd3KtkplYWT102C5sn/EZTY4XROkxONgruHPU72l+gW+FfF8tf2cFjeHaRbWpOYa/uRBz/Xq1Pg==",
|
||||
"cpu": [
|
||||
"ia32"
|
||||
],
|
||||
@@ -203,9 +202,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/linux-loong64": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.4.tgz",
|
||||
"integrity": "sha512-NeqqYkrcGzFwi6CGRGNMOjWGGSYOpqwCjS9fvaUlX5s3zwOtn1qwg1s2iE2svBe4Q/YOG1q6875lcAoQK/F4VA==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.7.tgz",
|
||||
"integrity": "sha512-a4POruNM2oWsD4WKvBSEKGIiWQF8fZOAsycHOt6JBpZ+JN2n2JH9WAv56SOyu9X5IqAjqSIPTaJkqN8F7XOQ5Q==",
|
||||
"cpu": [
|
||||
"loong64"
|
||||
],
|
||||
@@ -220,9 +219,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/linux-mips64el": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.4.tgz",
|
||||
"integrity": "sha512-IcvTlF9dtLrfL/M8WgNI/qJYBENP3ekgsHbYUIzEzq5XJzzVEV/fXY9WFPfEEXmu3ck2qJP8LG/p3Q8f7Zc2Xg==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.7.tgz",
|
||||
"integrity": "sha512-KabT5I6StirGfIz0FMgl1I+R1H73Gp0ofL9A3nG3i/cYFJzKHhouBV5VWK1CSgKvVaG4q1RNpCTR2LuTVB3fIw==",
|
||||
"cpu": [
|
||||
"mips64el"
|
||||
],
|
||||
@@ -237,9 +236,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/linux-ppc64": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.4.tgz",
|
||||
"integrity": "sha512-HOy0aLTJTVtoTeGZh4HSXaO6M95qu4k5lJcH4gxv56iaycfz1S8GO/5Jh6X4Y1YiI0h7cRyLi+HixMR+88swag==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.7.tgz",
|
||||
"integrity": "sha512-gRsL4x6wsGHGRqhtI+ifpN/vpOFTQtnbsupUF5R5YTAg+y/lKelYR1hXbnBdzDjGbMYjVJLJTd2OFmMewAgwlQ==",
|
||||
"cpu": [
|
||||
"ppc64"
|
||||
],
|
||||
@@ -254,9 +253,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/linux-riscv64": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.4.tgz",
|
||||
"integrity": "sha512-i8JUDAufpz9jOzo4yIShCTcXzS07vEgWzyX3NH2G7LEFVgrLEhjwL3ajFE4fZI3I4ZgiM7JH3GQ7ReObROvSUA==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.7.tgz",
|
||||
"integrity": "sha512-hL25LbxO1QOngGzu2U5xeXtxXcW+/GvMN3ejANqXkxZ/opySAZMrc+9LY/WyjAan41unrR3YrmtTsUpwT66InQ==",
|
||||
"cpu": [
|
||||
"riscv64"
|
||||
],
|
||||
@@ -271,9 +270,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/linux-s390x": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.4.tgz",
|
||||
"integrity": "sha512-jFnu+6UbLlzIjPQpWCNh5QtrcNfMLjgIavnwPQAfoGx4q17ocOU9MsQ2QVvFxwQoWpZT8DvTLooTvmOQXkO51g==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.7.tgz",
|
||||
"integrity": "sha512-2k8go8Ycu1Kb46vEelhu1vqEP+UeRVj2zY1pSuPdgvbd5ykAw82Lrro28vXUrRmzEsUV0NzCf54yARIK8r0fdw==",
|
||||
"cpu": [
|
||||
"s390x"
|
||||
],
|
||||
@@ -288,9 +287,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/linux-x64": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.4.tgz",
|
||||
"integrity": "sha512-6e0cvXwzOnVWJHq+mskP8DNSrKBr1bULBvnFLpc1KY+d+irZSgZ02TGse5FsafKS5jg2e4pbvK6TPXaF/A6+CA==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.7.tgz",
|
||||
"integrity": "sha512-hzznmADPt+OmsYzw1EE33ccA+HPdIqiCRq7cQeL1Jlq2gb1+OyWBkMCrYGBJ+sxVzve2ZJEVeePbLM2iEIZSxA==",
|
||||
"cpu": [
|
||||
"x64"
|
||||
],
|
||||
@@ -305,9 +304,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/netbsd-arm64": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.4.tgz",
|
||||
"integrity": "sha512-vUnkBYxZW4hL/ie91hSqaSNjulOnYXE1VSLusnvHg2u3jewJBz3YzB9+oCw8DABeVqZGg94t9tyZFoHma8gWZQ==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.7.tgz",
|
||||
"integrity": "sha512-b6pqtrQdigZBwZxAn1UpazEisvwaIDvdbMbmrly7cDTMFnw/+3lVxxCTGOrkPVnsYIosJJXAsILG9XcQS+Yu6w==",
|
||||
"cpu": [
|
||||
"arm64"
|
||||
],
|
||||
@@ -322,9 +321,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/netbsd-x64": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.4.tgz",
|
||||
"integrity": "sha512-XAg8pIQn5CzhOB8odIcAm42QsOfa98SBeKUdo4xa8OvX8LbMZqEtgeWE9P/Wxt7MlG2QqvjGths+nq48TrUiKw==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.7.tgz",
|
||||
"integrity": "sha512-OfatkLojr6U+WN5EDYuoQhtM+1xco+/6FSzJJnuWiUw5eVcicbyK3dq5EeV/QHT1uy6GoDhGbFpprUiHUYggrw==",
|
||||
"cpu": [
|
||||
"x64"
|
||||
],
|
||||
@@ -339,9 +338,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/openbsd-arm64": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.4.tgz",
|
||||
"integrity": "sha512-Ct2WcFEANlFDtp1nVAXSNBPDxyU+j7+tId//iHXU2f/lN5AmO4zLyhDcpR5Cz1r08mVxzt3Jpyt4PmXQ1O6+7A==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.7.tgz",
|
||||
"integrity": "sha512-AFuojMQTxAz75Fo8idVcqoQWEHIXFRbOc1TrVcFSgCZtQfSdc1RXgB3tjOn/krRHENUB4j00bfGjyl2mJrU37A==",
|
||||
"cpu": [
|
||||
"arm64"
|
||||
],
|
||||
@@ -356,9 +355,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/openbsd-x64": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.4.tgz",
|
||||
"integrity": "sha512-xAGGhyOQ9Otm1Xu8NT1ifGLnA6M3sJxZ6ixylb+vIUVzvvd6GOALpwQrYrtlPouMqd/vSbgehz6HaVk4+7Afhw==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.7.tgz",
|
||||
"integrity": "sha512-+A1NJmfM8WNDv5CLVQYJ5PshuRm/4cI6WMZRg1by1GwPIQPCTs1GLEUHwiiQGT5zDdyLiRM/l1G0Pv54gvtKIg==",
|
||||
"cpu": [
|
||||
"x64"
|
||||
],
|
||||
@@ -372,10 +371,27 @@
|
||||
"node": ">=18"
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/openharmony-arm64": {
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.7.tgz",
|
||||
"integrity": "sha512-+KrvYb/C8zA9CU/g0sR6w2RBw7IGc5J2BPnc3dYc5VJxHCSF1yNMxTV5LQ7GuKteQXZtspjFbiuW5/dOj7H4Yw==",
|
||||
"cpu": [
|
||||
"arm64"
|
||||
],
|
||||
"dev": true,
|
||||
"license": "MIT",
|
||||
"optional": true,
|
||||
"os": [
|
||||
"openharmony"
|
||||
],
|
||||
"engines": {
|
||||
"node": ">=18"
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/sunos-x64": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.4.tgz",
|
||||
"integrity": "sha512-Mw+tzy4pp6wZEK0+Lwr76pWLjrtjmJyUB23tHKqEDP74R3q95luY/bXqXZeYl4NYlvwOqoRKlInQialgCKy67Q==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.7.tgz",
|
||||
"integrity": "sha512-ikktIhFBzQNt/QDyOL580ti9+5mL/YZeUPKU2ivGtGjdTYoqz6jObj6nOMfhASpS4GU4Q/Clh1QtxWAvcYKamA==",
|
||||
"cpu": [
|
||||
"x64"
|
||||
],
|
||||
@@ -390,9 +406,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/win32-arm64": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.4.tgz",
|
||||
"integrity": "sha512-AVUP428VQTSddguz9dO9ngb+E5aScyg7nOeJDrF1HPYu555gmza3bDGMPhmVXL8svDSoqPCsCPjb265yG/kLKQ==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.7.tgz",
|
||||
"integrity": "sha512-7yRhbHvPqSpRUV7Q20VuDwbjW5kIMwTHpptuUzV+AA46kiPze5Z7qgt6CLCK3pWFrHeNfDd1VKgyP4O+ng17CA==",
|
||||
"cpu": [
|
||||
"arm64"
|
||||
],
|
||||
@@ -407,9 +423,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/win32-ia32": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.4.tgz",
|
||||
"integrity": "sha512-i1sW+1i+oWvQzSgfRcxxG2k4I9n3O9NRqy8U+uugaT2Dy7kLO9Y7wI72haOahxceMX8hZAzgGou1FhndRldxRg==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.7.tgz",
|
||||
"integrity": "sha512-SmwKXe6VHIyZYbBLJrhOoCJRB/Z1tckzmgTLfFYOfpMAx63BJEaL9ExI8x7v0oAO3Zh6D/Oi1gVxEYr5oUCFhw==",
|
||||
"cpu": [
|
||||
"ia32"
|
||||
],
|
||||
@@ -424,9 +440,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/win32-x64": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.4.tgz",
|
||||
"integrity": "sha512-nOT2vZNw6hJ+z43oP1SPea/G/6AbN6X+bGNhNuq8NtRHy4wsMhw765IKLNmnjek7GvjWBYQ8Q5VBoYTFg9y1UQ==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.7.tgz",
|
||||
"integrity": "sha512-56hiAJPhwQ1R4i+21FVF7V8kSD5zZTdHcVuRFMW0hn753vVfQN8xlx4uOPT4xoGH0Z/oVATuR82AiqSTDIpaHg==",
|
||||
"cpu": [
|
||||
"x64"
|
||||
],
|
||||
@@ -441,19 +457,19 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@types/node": {
|
||||
"version": "22.15.21",
|
||||
"resolved": "https://registry.npmjs.org/@types/node/-/node-22.15.21.tgz",
|
||||
"integrity": "sha512-EV/37Td6c+MgKAbkcLG6vqZ2zEYHD7bvSrzqqs2RIhbA6w3x+Dqz8MZM3sP6kGTeLrdoOgKZe+Xja7tUB2DNkQ==",
|
||||
"version": "25.5.2",
|
||||
"resolved": "https://registry.npmjs.org/@types/node/-/node-25.5.2.tgz",
|
||||
"integrity": "sha512-tO4ZIRKNC+MDWV4qKVZe3Ql/woTnmHDr5JD8UI5hn2pwBrHEwOEMZK7WlNb5RKB6EoJ02gwmQS9OrjuFnZYdpg==",
|
||||
"dev": true,
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"undici-types": "~6.21.0"
|
||||
"undici-types": "~7.18.0"
|
||||
}
|
||||
},
|
||||
"node_modules/esbuild": {
|
||||
"version": "0.25.4",
|
||||
"resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.4.tgz",
|
||||
"integrity": "sha512-8pgjLUcUjcgDg+2Q4NYXnPbo/vncAY4UmyaCm0jZevERqCHZIaWwdJHkf8XQtu4AxSKCdvrUbT0XUr1IdZzI8Q==",
|
||||
"version": "0.27.7",
|
||||
"resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.7.tgz",
|
||||
"integrity": "sha512-IxpibTjyVnmrIQo5aqNpCgoACA/dTKLTlhMHihVHhdkxKyPO1uBBthumT0rdHmcsk9uMonIWS0m4FljWzILh3w==",
|
||||
"dev": true,
|
||||
"hasInstallScript": true,
|
||||
"license": "MIT",
|
||||
@@ -464,31 +480,32 @@
|
||||
"node": ">=18"
|
||||
},
|
||||
"optionalDependencies": {
|
||||
"@esbuild/aix-ppc64": "0.25.4",
|
||||
"@esbuild/android-arm": "0.25.4",
|
||||
"@esbuild/android-arm64": "0.25.4",
|
||||
"@esbuild/android-x64": "0.25.4",
|
||||
"@esbuild/darwin-arm64": "0.25.4",
|
||||
"@esbuild/darwin-x64": "0.25.4",
|
||||
"@esbuild/freebsd-arm64": "0.25.4",
|
||||
"@esbuild/freebsd-x64": "0.25.4",
|
||||
"@esbuild/linux-arm": "0.25.4",
|
||||
"@esbuild/linux-arm64": "0.25.4",
|
||||
"@esbuild/linux-ia32": "0.25.4",
|
||||
"@esbuild/linux-loong64": "0.25.4",
|
||||
"@esbuild/linux-mips64el": "0.25.4",
|
||||
"@esbuild/linux-ppc64": "0.25.4",
|
||||
"@esbuild/linux-riscv64": "0.25.4",
|
||||
"@esbuild/linux-s390x": "0.25.4",
|
||||
"@esbuild/linux-x64": "0.25.4",
|
||||
"@esbuild/netbsd-arm64": "0.25.4",
|
||||
"@esbuild/netbsd-x64": "0.25.4",
|
||||
"@esbuild/openbsd-arm64": "0.25.4",
|
||||
"@esbuild/openbsd-x64": "0.25.4",
|
||||
"@esbuild/sunos-x64": "0.25.4",
|
||||
"@esbuild/win32-arm64": "0.25.4",
|
||||
"@esbuild/win32-ia32": "0.25.4",
|
||||
"@esbuild/win32-x64": "0.25.4"
|
||||
"@esbuild/aix-ppc64": "0.27.7",
|
||||
"@esbuild/android-arm": "0.27.7",
|
||||
"@esbuild/android-arm64": "0.27.7",
|
||||
"@esbuild/android-x64": "0.27.7",
|
||||
"@esbuild/darwin-arm64": "0.27.7",
|
||||
"@esbuild/darwin-x64": "0.27.7",
|
||||
"@esbuild/freebsd-arm64": "0.27.7",
|
||||
"@esbuild/freebsd-x64": "0.27.7",
|
||||
"@esbuild/linux-arm": "0.27.7",
|
||||
"@esbuild/linux-arm64": "0.27.7",
|
||||
"@esbuild/linux-ia32": "0.27.7",
|
||||
"@esbuild/linux-loong64": "0.27.7",
|
||||
"@esbuild/linux-mips64el": "0.27.7",
|
||||
"@esbuild/linux-ppc64": "0.27.7",
|
||||
"@esbuild/linux-riscv64": "0.27.7",
|
||||
"@esbuild/linux-s390x": "0.27.7",
|
||||
"@esbuild/linux-x64": "0.27.7",
|
||||
"@esbuild/netbsd-arm64": "0.27.7",
|
||||
"@esbuild/netbsd-x64": "0.27.7",
|
||||
"@esbuild/openbsd-arm64": "0.27.7",
|
||||
"@esbuild/openbsd-x64": "0.27.7",
|
||||
"@esbuild/openharmony-arm64": "0.27.7",
|
||||
"@esbuild/sunos-x64": "0.27.7",
|
||||
"@esbuild/win32-arm64": "0.27.7",
|
||||
"@esbuild/win32-ia32": "0.27.7",
|
||||
"@esbuild/win32-x64": "0.27.7"
|
||||
}
|
||||
},
|
||||
"node_modules/fsevents": {
|
||||
@@ -507,9 +524,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/get-tsconfig": {
|
||||
"version": "4.7.6",
|
||||
"resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.7.6.tgz",
|
||||
"integrity": "sha512-ZAqrLlu18NbDdRaHq+AKXzAmqIUPswPWKUchfytdAjiRFnCe5ojG2bstg6mRiZabkKfCoL/e98pbBELIV/YCeA==",
|
||||
"version": "4.13.7",
|
||||
"resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.13.7.tgz",
|
||||
"integrity": "sha512-7tN6rFgBlMgpBML5j8typ92BKFi2sFQvIdpAqLA2beia5avZDrMs0FLZiM5etShWq5irVyGcGMEA1jcDaK7A/Q==",
|
||||
"dev": true,
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -530,13 +547,13 @@
|
||||
}
|
||||
},
|
||||
"node_modules/tsx": {
|
||||
"version": "4.19.4",
|
||||
"resolved": "https://registry.npmjs.org/tsx/-/tsx-4.19.4.tgz",
|
||||
"integrity": "sha512-gK5GVzDkJK1SI1zwHf32Mqxf2tSJkNx+eYcNly5+nHvWqXUJYUkWBQtKauoESz3ymezAI++ZwT855x5p5eop+Q==",
|
||||
"version": "4.21.0",
|
||||
"resolved": "https://registry.npmjs.org/tsx/-/tsx-4.21.0.tgz",
|
||||
"integrity": "sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==",
|
||||
"dev": true,
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"esbuild": "~0.25.0",
|
||||
"esbuild": "~0.27.0",
|
||||
"get-tsconfig": "^4.7.5"
|
||||
},
|
||||
"bin": {
|
||||
@@ -550,9 +567,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/typescript": {
|
||||
"version": "5.8.3",
|
||||
"resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz",
|
||||
"integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==",
|
||||
"version": "6.0.2",
|
||||
"resolved": "https://registry.npmjs.org/typescript/-/typescript-6.0.2.tgz",
|
||||
"integrity": "sha512-bGdAIrZ0wiGDo5l8c++HWtbaNCWTS4UTv7RaTH/ThVIgjkveJt83m74bBHMJkuCbslY8ixgLBVZJIOiQlQTjfQ==",
|
||||
"dev": true,
|
||||
"license": "Apache-2.0",
|
||||
"bin": {
|
||||
@@ -564,9 +581,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/undici-types": {
|
||||
"version": "6.21.0",
|
||||
"resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
|
||||
"integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
|
||||
"version": "7.18.2",
|
||||
"resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.18.2.tgz",
|
||||
"integrity": "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==",
|
||||
"dev": true,
|
||||
"license": "MIT"
|
||||
}
|
||||
|
||||
18
package.json
18
package.json
@@ -6,15 +6,23 @@
|
||||
"type": "module",
|
||||
"scripts": {
|
||||
"start": "tsx src/index.ts",
|
||||
"test": "tsx src/test.ts",
|
||||
"build": "tsc && esbuild --bundle --minify --sourcemap --platform=node --target=node20 --outdir=build src/index.ts"
|
||||
"test": "tsx src/test.ts"
|
||||
},
|
||||
"author": "Hervé BECHER",
|
||||
"license": "ISC",
|
||||
"devDependencies": {
|
||||
"@types/node": "^22.15.21",
|
||||
"esbuild": "^0.25.4",
|
||||
"@types/node": "^25.5.0",
|
||||
"tsx": "^4.19.4",
|
||||
"typescript": "^5.8.3"
|
||||
"typescript": "^6.0.2"
|
||||
},
|
||||
"exports": {
|
||||
".": {
|
||||
"import": "./src/index.ts",
|
||||
"types": "./src/index.ts"
|
||||
},
|
||||
"./*": {
|
||||
"import": "./src/*.ts",
|
||||
"types": "./src/*.ts"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,17 +1,17 @@
|
||||
import { Collector } from "../collector/types.js";
|
||||
import { asAsyncComparer, combineNullableAsyncComparers, createAsyncComparerUsing, defaultAsyncComparer } from "../comparer/async.js";
|
||||
import { asAsyncComparer, combineAsyncComparers, createAsyncComparerUsing, defaultAsyncComparer } from "../comparer/async.js";
|
||||
import { MaybeAsyncComparisonOrComparer, AsyncComparer } from "../comparer/types.js";
|
||||
import { strictEquals, identity } from "../equality-comparer/index.js";
|
||||
import { MaybeAsyncEqualityComparison } from "../equality-comparer/types.js";
|
||||
import { createAsyncEqualityMap } from "../equality-map.js";
|
||||
import { createAsyncEqualitySet } from "../equality-set.js";
|
||||
import { asAsyncEqualityComparer, defaultAsyncEqualityComparer } from "../equality-comparer/async.js";
|
||||
import { AsyncEqualityComparer, MaybeAsyncEqualityComparisonOrComparer } from "../equality-comparer/types.js";
|
||||
import { createAsyncEqualityMap } from "../equality-map/index.js";
|
||||
import { createAsyncEqualitySet } from "../equality-set/index.js";
|
||||
import { createQueue } from "../queue.js";
|
||||
import { getRandomElementAsync } from "../random/index.js";
|
||||
import { AsyncRandomOptions } from "../random/types.js";
|
||||
import { selectionSorter } from "../sorting.js";
|
||||
import { Sequence } from "../sync/types.js";
|
||||
import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncAction, MaybePromiseLike, MaybeAsyncGenerator, MaybePromise, MaybeAsyncIterable, MaybeAsyncTypePredicate } from "../types.js";
|
||||
import { asAsyncIterable } from "../utils.js";
|
||||
import { asAsyncIterable, FindElementResult, identity } from "../utils.js";
|
||||
import { array, empty, wrap } from "./index.js";
|
||||
import { AsyncSequence, AsyncSequencePipeline, GroupedAsyncSequence, OrderedAsyncSequence } from "./types.js";
|
||||
|
||||
@@ -42,31 +42,29 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
|
||||
return new WhereAsyncSequence<TElement, any>(this, predicate);
|
||||
}
|
||||
|
||||
groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
|
||||
groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
|
||||
groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
|
||||
groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
|
||||
groupBy(keySelector: any, elementSelector?: any, keyComparer?: any) {
|
||||
return new GroupByAsyncSequence<any, any, any>(this, keySelector, elementSelector, keyComparer);
|
||||
}
|
||||
|
||||
join<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<[TElement, TOther]>;
|
||||
join<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<TResult>;
|
||||
join<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<[TElement, TOther]>;
|
||||
join<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<TResult>;
|
||||
join(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
|
||||
return new JoinAsyncSequence<any, any, any, any>(this, wrap(sequence), firstKeySelector, secondKeySelector, resultSelector, keyComparer);
|
||||
}
|
||||
|
||||
groupJoin<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
|
||||
groupJoin<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, MaybeAsyncIterable<TOther>, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<TResult>;
|
||||
groupJoin<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
|
||||
groupJoin<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, MaybeAsyncIterable<TOther>, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<TResult>;
|
||||
groupJoin(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
|
||||
return new GroupJoinAsyncSequence<any, any, any, any>(this, wrap(sequence), firstKeySelector, secondKeySelector, resultSelector, keyComparer);
|
||||
}
|
||||
|
||||
async contains(obj: TElement, equater?: MaybeAsyncEqualityComparison<TElement>) {
|
||||
if (!equater) {
|
||||
equater = strictEquals;
|
||||
}
|
||||
async contains(obj: TElement, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>) {
|
||||
equater = equater ? asAsyncEqualityComparer(equater) : defaultAsyncEqualityComparer;
|
||||
|
||||
for await (const element of this) {
|
||||
if (await equater(element, obj)) {
|
||||
if (await equater.equals(element, obj)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -74,7 +72,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
|
||||
return false;
|
||||
}
|
||||
|
||||
async sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>) {
|
||||
async sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>) {
|
||||
if (this === sequence) {
|
||||
return true;
|
||||
}
|
||||
@@ -88,9 +86,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!equater) {
|
||||
equater = strictEquals;
|
||||
}
|
||||
equater = equater ? asAsyncEqualityComparer(equater) : defaultAsyncEqualityComparer;
|
||||
|
||||
const thisIterator = this.iterator();
|
||||
const thatIterator = that.iterator();
|
||||
@@ -107,7 +103,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!await equater(thisNext.value, thatNext.value)) {
|
||||
if (!await equater.equals(thisNext.value, thatNext.value)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -121,7 +117,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
|
||||
return new PrependAsyncSequence<TElement>(this, obj);
|
||||
}
|
||||
|
||||
remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement> {
|
||||
remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement> {
|
||||
return new RemoveAsyncSequence<TElement>(this, obj, all, equater);
|
||||
}
|
||||
|
||||
@@ -173,14 +169,14 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
|
||||
return n >= 0 ? n : Infinity;
|
||||
}
|
||||
|
||||
async #tryGetFirst(predicate?: MaybeAsyncAnyPredicate<TElement>) {
|
||||
async #tryGetFirst(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<FindElementResult<TElement>> {
|
||||
if (predicate) {
|
||||
for await (const element of this) {
|
||||
if (await predicate(element)) {
|
||||
return {
|
||||
found: true,
|
||||
element
|
||||
} as const;
|
||||
};
|
||||
}
|
||||
}
|
||||
} else {
|
||||
@@ -190,13 +186,13 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
|
||||
return {
|
||||
found: true,
|
||||
element: next.value
|
||||
} as const;
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
found: false
|
||||
} as const;
|
||||
};
|
||||
}
|
||||
|
||||
async first(predicate?: MaybeAsyncAnyPredicate<TElement>) {
|
||||
@@ -215,35 +211,37 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
|
||||
return result.found ? result.element : def;
|
||||
}
|
||||
|
||||
async #tryGetLast(predicate?: MaybeAsyncAnyPredicate<TElement>) {
|
||||
let found = false;
|
||||
let result: TElement | undefined = undefined;
|
||||
async #tryGetLast(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<FindElementResult<TElement>> {
|
||||
let result: FindElementResult<TElement> = {
|
||||
found: false
|
||||
};
|
||||
|
||||
if (predicate) {
|
||||
for await (const element of this) {
|
||||
if (await predicate(element)) {
|
||||
found = true;
|
||||
result = element;
|
||||
result = {
|
||||
found: true,
|
||||
element
|
||||
};
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for await (const element of this) {
|
||||
found = true;
|
||||
result = element;
|
||||
result = {
|
||||
found: true,
|
||||
element
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
found,
|
||||
element: result
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
async last(predicate?: MaybeAsyncAnyPredicate<TElement>) {
|
||||
const result = await this.#tryGetLast(predicate);
|
||||
|
||||
if (result.found) {
|
||||
return result.element!;
|
||||
return result.element;
|
||||
}
|
||||
|
||||
throw new Error("No element was found.");
|
||||
@@ -255,9 +253,9 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
|
||||
return result.found ? result.element : def;
|
||||
}
|
||||
|
||||
async #tryGetSingle(predicate?: MaybeAsyncAnyPredicate<TElement>) {
|
||||
async #tryGetSingle(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<FindElementResult<TElement>> {
|
||||
if (predicate) {
|
||||
let result: { found: true; element: TElement; } | undefined = undefined;
|
||||
let result: FindElementResult<TElement> | undefined = undefined;
|
||||
|
||||
for await (const element of this) {
|
||||
if (await predicate(element)) {
|
||||
@@ -265,13 +263,13 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
|
||||
return {
|
||||
found: false,
|
||||
reason: 2
|
||||
} as const;
|
||||
};
|
||||
}
|
||||
|
||||
result = {
|
||||
found: true,
|
||||
element
|
||||
} as const;
|
||||
};
|
||||
}
|
||||
}
|
||||
} else {
|
||||
@@ -279,10 +277,10 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
|
||||
let next = await iterator.next();
|
||||
|
||||
if (!next.done) {
|
||||
const result = {
|
||||
const result: FindElementResult<TElement> = {
|
||||
found: true,
|
||||
element: next.value
|
||||
} as const;
|
||||
};
|
||||
|
||||
next = await iterator.next();
|
||||
|
||||
@@ -293,20 +291,20 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
|
||||
return {
|
||||
found: false,
|
||||
reason: 2
|
||||
} as const;
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
found: false,
|
||||
reason: 1
|
||||
} as const;
|
||||
};
|
||||
}
|
||||
|
||||
async single(predicate?: MaybeAsyncAnyPredicate<TElement>) {
|
||||
const result = await this.#tryGetSingle(predicate);
|
||||
|
||||
if (result.found == true) {
|
||||
if (result.found) {
|
||||
return result.element;
|
||||
}
|
||||
|
||||
@@ -330,7 +328,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
|
||||
return result.found ? result.element : def;
|
||||
}
|
||||
|
||||
async #tryElementAt(index: number) {
|
||||
async #tryElementAt(index: number): Promise<FindElementResult<TElement>> {
|
||||
let i = index;
|
||||
|
||||
for await (const element of this) {
|
||||
@@ -338,7 +336,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
|
||||
return {
|
||||
found: true,
|
||||
element
|
||||
} as const;
|
||||
};
|
||||
}
|
||||
|
||||
i--;
|
||||
@@ -346,7 +344,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
|
||||
|
||||
return {
|
||||
found: false
|
||||
} as const;
|
||||
};
|
||||
}
|
||||
|
||||
async elementAt(index: number) {
|
||||
@@ -516,27 +514,27 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
|
||||
return new OrderByAsyncSequence<TElement, TBy>(this, true, selector, comparer);
|
||||
}
|
||||
|
||||
partition(equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<AsyncSequence<TElement>> {
|
||||
partition(equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<AsyncSequence<TElement>> {
|
||||
return new PartitionAsyncSequence<TElement>(this, equater);
|
||||
}
|
||||
|
||||
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<AsyncSequence<TElement>> {
|
||||
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<AsyncSequence<TElement>> {
|
||||
return new PartitionByAsyncSequence<TElement, TBy>(this, selector, equater);
|
||||
}
|
||||
|
||||
distinct(equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement> {
|
||||
distinct(equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement> {
|
||||
return new DistinctAsyncSequence<TElement>(this, equater);
|
||||
}
|
||||
|
||||
distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement> {
|
||||
distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<TElement> {
|
||||
return new DistinctByAsyncSequence<TElement, TBy>(this, selector, equater);
|
||||
}
|
||||
|
||||
union(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement> {
|
||||
union(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement> {
|
||||
return new UnionAsyncSequence<TElement>(this, wrap(sequence), equater);
|
||||
}
|
||||
|
||||
unionBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement> {
|
||||
unionBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<TElement> {
|
||||
return new UnionByAsyncSequence<TElement, TBy>(this, wrap(sequence), selector, equater);
|
||||
}
|
||||
|
||||
@@ -666,6 +664,10 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
|
||||
return new ZippedAsyncSequence<TElement, TOther>(this, wrap(sequence));
|
||||
}
|
||||
|
||||
cartesianProduct<TOther>(sequence: MaybeAsyncIterable<TOther>): AsyncSequence<[TElement, TOther]> {
|
||||
return new CartesianProductAsyncSequence<TElement, TOther>(this, wrap(sequence));
|
||||
}
|
||||
|
||||
indexed(): AsyncSequence<[number, TElement]> {
|
||||
return new IndexedAsyncSequence<TElement>(this);
|
||||
}
|
||||
@@ -693,18 +695,12 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
|
||||
return new CacheAsyncSequence<TElement>(this);
|
||||
}
|
||||
|
||||
async asArray(): Promise<TElement[]> {
|
||||
return await this.toArray();
|
||||
async asArray() {
|
||||
return await Array.fromAsync(this);
|
||||
}
|
||||
|
||||
async toArray() {
|
||||
const array: TElement[] = [];
|
||||
|
||||
for await (const element of this) {
|
||||
array.push(element);
|
||||
}
|
||||
|
||||
return array;
|
||||
return await Array.fromAsync(this);
|
||||
}
|
||||
|
||||
toMap<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>): Promise<Map<TKey, TElement>>;
|
||||
@@ -817,29 +813,29 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
|
||||
return this.#sequence.where(predicate);
|
||||
}
|
||||
|
||||
groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
|
||||
groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
|
||||
groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
|
||||
groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
|
||||
groupBy(keySelector: any, elementSelector?: any, keyComparer?: any) {
|
||||
return this.#sequence.groupBy(keySelector, elementSelector, keyComparer);
|
||||
}
|
||||
|
||||
join<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<[TElement, TOther]>;
|
||||
join<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<TResult>;
|
||||
join<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<[TElement, TOther]>;
|
||||
join<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<TResult>;
|
||||
join(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
|
||||
return this.#sequence.join(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
|
||||
}
|
||||
|
||||
groupJoin<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
|
||||
groupJoin<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, MaybeAsyncIterable<TOther>, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<TResult>;
|
||||
groupJoin<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
|
||||
groupJoin<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, MaybeAsyncIterable<TOther>, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<TResult>;
|
||||
groupJoin(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
|
||||
return this.#sequence.groupJoin(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
|
||||
}
|
||||
|
||||
contains(obj: TElement, equater?: MaybeAsyncEqualityComparison<TElement> | undefined): Promise<boolean> {
|
||||
contains(obj: TElement, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): Promise<boolean> {
|
||||
return this.#sequence.contains(obj, equater);
|
||||
}
|
||||
|
||||
sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement> | undefined): Promise<boolean> {
|
||||
sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): Promise<boolean> {
|
||||
return this.#sequence.sequenceEquals(sequence, equater);
|
||||
}
|
||||
|
||||
@@ -851,7 +847,7 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
|
||||
return this.#sequence.prepend(obj);
|
||||
}
|
||||
|
||||
remove(obj: TElement, all?: boolean | undefined, equater?: MaybeAsyncEqualityComparison<TElement> | undefined): AsyncSequence<TElement> {
|
||||
remove(obj: TElement, all?: boolean | undefined, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): AsyncSequence<TElement> {
|
||||
return this.#sequence.remove(obj, all, equater);
|
||||
}
|
||||
|
||||
@@ -922,59 +918,59 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
|
||||
return this.#sequence.boundsBy(selector, comparer);
|
||||
}
|
||||
|
||||
order(comparer?: MaybeAsyncComparisonOrComparer<TElement> | undefined): AsyncSequence<TElement> {
|
||||
order(comparer?: MaybeAsyncComparisonOrComparer<TElement> | undefined): OrderedAsyncSequence<TElement> {
|
||||
return this.#sequence.order(comparer);
|
||||
}
|
||||
|
||||
orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy> | undefined): AsyncSequence<TElement> {
|
||||
orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy> | undefined): OrderedAsyncSequence<TElement> {
|
||||
return this.#sequence.orderBy(selector, comparer);
|
||||
}
|
||||
|
||||
orderDescending(comparer?: MaybeAsyncComparisonOrComparer<TElement> | undefined): AsyncSequence<TElement> {
|
||||
orderDescending(comparer?: MaybeAsyncComparisonOrComparer<TElement> | undefined): OrderedAsyncSequence<TElement> {
|
||||
return this.#sequence.orderDescending(comparer);
|
||||
}
|
||||
|
||||
orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy> | undefined): AsyncSequence<TElement> {
|
||||
orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy> | undefined): OrderedAsyncSequence<TElement> {
|
||||
return this.#sequence.orderByDescending(selector, comparer);
|
||||
}
|
||||
|
||||
partition(equater?: MaybeAsyncEqualityComparison<TElement> | undefined): AsyncSequence<AsyncSequence<TElement>> {
|
||||
partition(equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): AsyncSequence<AsyncSequence<TElement>> {
|
||||
return this.#sequence.partition(equater);
|
||||
}
|
||||
|
||||
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy> | undefined): AsyncSequence<AsyncSequence<TElement>> {
|
||||
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined): AsyncSequence<AsyncSequence<TElement>> {
|
||||
return this.#sequence.partitionBy(selector, equater);
|
||||
}
|
||||
|
||||
distinct(equater?: MaybeAsyncEqualityComparison<TElement> | undefined): AsyncSequence<TElement> {
|
||||
distinct(equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): AsyncSequence<TElement> {
|
||||
return this.#sequence.distinct(equater);
|
||||
}
|
||||
|
||||
distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy> | undefined): AsyncSequence<TElement> {
|
||||
distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined): AsyncSequence<TElement> {
|
||||
return this.#sequence.distinctBy(selector, equater);
|
||||
}
|
||||
|
||||
union(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement> | undefined): AsyncSequence<TElement> {
|
||||
union(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): AsyncSequence<TElement> {
|
||||
return this.#sequence.union(wrap(sequence), equater);
|
||||
}
|
||||
|
||||
unionBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy> | undefined): AsyncSequence<TElement> {
|
||||
unionBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined): AsyncSequence<TElement> {
|
||||
return this.#sequence.unionBy(wrap(sequence), selector, equater);
|
||||
}
|
||||
|
||||
except(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement> | undefined): AsyncSequence<TElement> {
|
||||
except(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): AsyncSequence<TElement> {
|
||||
return this.#sequence.except(wrap(sequence), equater);
|
||||
}
|
||||
|
||||
exceptBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy> | undefined): AsyncSequence<TElement> {
|
||||
exceptBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined): AsyncSequence<TElement> {
|
||||
return this.#sequence.exceptBy(wrap(sequence), selector, equater);
|
||||
}
|
||||
|
||||
intersect(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement> | undefined): AsyncSequence<TElement> {
|
||||
intersect(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): AsyncSequence<TElement> {
|
||||
return this.#sequence.intersect(wrap(sequence), equater);
|
||||
}
|
||||
|
||||
intersectBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy> | undefined): AsyncSequence<TElement> {
|
||||
intersectBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined): AsyncSequence<TElement> {
|
||||
return this.#sequence.intersectBy(wrap(sequence), selector, equater);
|
||||
}
|
||||
|
||||
@@ -1030,6 +1026,10 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
|
||||
return this.#sequence.zip(wrap(sequence));
|
||||
}
|
||||
|
||||
cartesianProduct<TOther>(sequence: MaybeAsyncIterable<TOther>): AsyncSequence<[TElement, TOther]> {
|
||||
return this.#sequence.cartesianProduct(wrap(sequence));
|
||||
}
|
||||
|
||||
indexed(): AsyncSequence<[number, TElement]> {
|
||||
return this.#sequence.indexed();
|
||||
}
|
||||
@@ -1137,13 +1137,9 @@ abstract class BaseOrderedAsyncSequence<TElement> extends BaseAsyncSequence<TEle
|
||||
}
|
||||
|
||||
override async *iterator() {
|
||||
const arr: TElement[] = [];
|
||||
const arr = await Array.fromAsync(this.#sequence);
|
||||
|
||||
for await (const obj of this.#sequence) {
|
||||
arr.push(obj);
|
||||
}
|
||||
|
||||
await selectionSorter.sort(arr, this.#descending, this.#sorter.comparison());
|
||||
await selectionSorter.sort(arr, this.#descending, this.#sorter);
|
||||
|
||||
yield* arr;
|
||||
}
|
||||
@@ -1245,6 +1241,20 @@ export class WrappedObjectAsync<T> extends BaseAsyncSequence<T> {
|
||||
}
|
||||
}
|
||||
|
||||
export class WrappedPromise<T> extends BaseAsyncSequence<T> {
|
||||
readonly #promise: Promise<MaybeAsyncIterable<T>>;
|
||||
|
||||
constructor(promise: Promise<MaybeAsyncIterable<T>>) {
|
||||
super();
|
||||
|
||||
this.#promise = promise;
|
||||
}
|
||||
|
||||
override async *iterator() {
|
||||
yield* await this.#promise;
|
||||
}
|
||||
}
|
||||
|
||||
export class WrappedArrayAsync<T> extends BaseAsyncSequence<T> {
|
||||
readonly #array: ReadonlyArray<MaybePromiseLike<T>>;
|
||||
|
||||
@@ -1391,9 +1401,9 @@ export class ConcatAsyncSequence<T> extends BaseAsyncSequence<T> {
|
||||
|
||||
class DistinctAsyncSequence<T> extends BaseAsyncSequence<T> {
|
||||
readonly #sequence: AsyncSequence<T>;
|
||||
readonly #equater: MaybeAsyncEqualityComparison<T> | undefined;
|
||||
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<T> | undefined;
|
||||
|
||||
constructor(sequence: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparison<T>) {
|
||||
constructor(sequence: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparisonOrComparer<T>) {
|
||||
super();
|
||||
|
||||
this.#sequence = sequence;
|
||||
@@ -1414,9 +1424,9 @@ class DistinctAsyncSequence<T> extends BaseAsyncSequence<T> {
|
||||
class DistinctByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
|
||||
readonly #sequence: AsyncSequence<T>;
|
||||
readonly #selector: MaybeAsyncConverter<T, U>;
|
||||
readonly #equater: MaybeAsyncEqualityComparison<U> | undefined;
|
||||
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<U> | undefined;
|
||||
|
||||
constructor(sequence: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparison<U>) {
|
||||
constructor(sequence: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparisonOrComparer<U>) {
|
||||
super();
|
||||
|
||||
this.#sequence = sequence;
|
||||
@@ -1697,7 +1707,7 @@ class TakeAsyncSequence<T> extends BaseAsyncSequence<T> {
|
||||
return;
|
||||
}
|
||||
|
||||
yield next.value as T;
|
||||
yield next.value;
|
||||
i--;
|
||||
}
|
||||
}
|
||||
@@ -1717,13 +1727,13 @@ class OrderByAsyncSequence<T, U> extends BaseOrderedAsyncSequence<T> {
|
||||
|
||||
class ThenOrderAsyncSequence<T> extends BaseOrderedAsyncSequence<T> {
|
||||
constructor(sequence: OrderedAsyncSequence<T>, descending: boolean, sorter?: MaybeAsyncComparisonOrComparer<T>) {
|
||||
super(sequence, combineNullableAsyncComparers([sequence.comparer, sorter]), descending);
|
||||
super(sequence, combineAsyncComparers([sequence.comparer, sorter]), descending);
|
||||
}
|
||||
}
|
||||
|
||||
class ThenOrderByAsyncSequence<T, U> extends BaseOrderedAsyncSequence<T> {
|
||||
constructor(sequence: OrderedAsyncSequence<T>, descending: boolean, selector: MaybeAsyncConverter<T, U>, sorter?: MaybeAsyncComparisonOrComparer<U>) {
|
||||
super(sequence, combineNullableAsyncComparers([sequence.comparer, createAsyncComparerUsing(selector, sorter)]), descending);
|
||||
super(sequence, combineAsyncComparers([sequence.comparer, createAsyncComparerUsing(selector, sorter)]), descending);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1833,12 +1843,52 @@ class ZippedAsyncSequence<T, U> extends BaseAsyncSequence<[T, U]> {
|
||||
}
|
||||
}
|
||||
|
||||
export class CartesianProductAsyncSequence<T, U> extends BaseAsyncSequence<[T, U]> {
|
||||
readonly #first: AsyncSequence<T>;
|
||||
readonly #second: AsyncSequence<U>;
|
||||
|
||||
constructor(first: AsyncSequence<T>, second: AsyncSequence<U>) {
|
||||
super();
|
||||
|
||||
this.#first = first;
|
||||
this.#second = second;
|
||||
}
|
||||
|
||||
override async nonEnumeratedCount() {
|
||||
const n1 = await this.#first.nonEnumeratedCount();
|
||||
|
||||
if (n1 < 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
const n2 = await this.#second.nonEnumeratedCount();
|
||||
|
||||
if (n2 < 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
return n1 * n2;
|
||||
}
|
||||
|
||||
override async maxCount() {
|
||||
return await this.#first.maxCount() * await this.#second.maxCount();
|
||||
}
|
||||
|
||||
override async *iterator() {
|
||||
for await (const firstObj of this.#first) {
|
||||
for await (const secondObj of this.#second) {
|
||||
yield [firstObj, secondObj] as [T, U];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class UnionAsyncSequence<T> extends BaseAsyncSequence<T> {
|
||||
readonly #first: AsyncSequence<T>;
|
||||
readonly #second: AsyncSequence<T>;
|
||||
readonly #equater: MaybeAsyncEqualityComparison<T> | undefined;
|
||||
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<T> | undefined;
|
||||
|
||||
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparison<T>) {
|
||||
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparisonOrComparer<T>) {
|
||||
super();
|
||||
|
||||
this.#first = first;
|
||||
@@ -1869,9 +1919,9 @@ class UnionByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
|
||||
readonly #first: AsyncSequence<T>;
|
||||
readonly #second: AsyncSequence<T>;
|
||||
readonly #selector: MaybeAsyncConverter<T, U>;
|
||||
readonly #equater: MaybeAsyncEqualityComparison<U> | undefined;
|
||||
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<U> | undefined;
|
||||
|
||||
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparison<U>) {
|
||||
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparisonOrComparer<U>) {
|
||||
super();
|
||||
|
||||
this.#first = first;
|
||||
@@ -1902,9 +1952,9 @@ class UnionByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
|
||||
class ExceptAsyncSequence<T> extends BaseAsyncSequence<T> {
|
||||
readonly #first: AsyncSequence<T>;
|
||||
readonly #second: AsyncSequence<T>;
|
||||
readonly #equater: MaybeAsyncEqualityComparison<T> | undefined;
|
||||
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<T> | undefined;
|
||||
|
||||
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparison<T>) {
|
||||
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparisonOrComparer<T>) {
|
||||
super();
|
||||
|
||||
this.#first = first;
|
||||
@@ -1933,9 +1983,9 @@ class ExceptByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
|
||||
readonly #first: AsyncSequence<T>;
|
||||
readonly #second: AsyncSequence<T>;
|
||||
readonly #selector: MaybeAsyncConverter<T, U>;
|
||||
readonly #equater: MaybeAsyncEqualityComparison<U> | undefined;
|
||||
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<U> | undefined;
|
||||
|
||||
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparison<U>) {
|
||||
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparisonOrComparer<U>) {
|
||||
super();
|
||||
|
||||
this.#first = first;
|
||||
@@ -1964,9 +2014,9 @@ class ExceptByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
|
||||
class IntersectAsyncSequence<T> extends BaseAsyncSequence<T> {
|
||||
readonly #first: AsyncSequence<T>;
|
||||
readonly #second: AsyncSequence<T>;
|
||||
readonly #equater: MaybeAsyncEqualityComparison<T> | undefined;
|
||||
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<T> | undefined;
|
||||
|
||||
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparison<T>) {
|
||||
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparisonOrComparer<T>) {
|
||||
super();
|
||||
|
||||
this.#first = first;
|
||||
@@ -1995,9 +2045,9 @@ class IntersectByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
|
||||
readonly #first: AsyncSequence<T>;
|
||||
readonly #second: AsyncSequence<T>;
|
||||
readonly #selector: MaybeAsyncConverter<T, U>;
|
||||
readonly #equater: MaybeAsyncEqualityComparison<U> | undefined;
|
||||
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<U> | undefined;
|
||||
|
||||
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparison<U>) {
|
||||
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparisonOrComparer<U>) {
|
||||
super();
|
||||
|
||||
this.#first = first;
|
||||
@@ -2049,9 +2099,9 @@ class GroupByAsyncSequence<TElement, TKey, TResult> extends BaseAsyncSequence<Gr
|
||||
readonly #sequence: AsyncSequence<TElement>;
|
||||
readonly #keySelector: MaybeAsyncConverter<TElement, TKey>;
|
||||
readonly #elementSelector: MaybeAsyncConverter<TElement, TResult>;
|
||||
readonly #keyComparer: MaybeAsyncEqualityComparison<TKey> | undefined;
|
||||
readonly #keyComparer: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined;
|
||||
|
||||
constructor(sequence: AsyncSequence<TElement>, keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey>) {
|
||||
constructor(sequence: AsyncSequence<TElement>, keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>) {
|
||||
super();
|
||||
|
||||
this.#sequence = sequence;
|
||||
@@ -2122,9 +2172,9 @@ class JoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSequence
|
||||
readonly #firstKeySelector: MaybeAsyncConverter<TOuter, TKey>;
|
||||
readonly #secondKeySelector: MaybeAsyncConverter<TInner, TKey>;
|
||||
readonly #resultSelector: MaybeAsyncBiConverter<TOuter, TInner, TResult>;
|
||||
readonly #keyComparer: MaybeAsyncEqualityComparison<TKey>;
|
||||
readonly #keyComparer: AsyncEqualityComparer<TKey>;
|
||||
|
||||
constructor(first: AsyncSequence<TOuter>, second: AsyncSequence<TInner>, firstKeySelector: MaybeAsyncConverter<TOuter, TKey>, secondKeySelector: MaybeAsyncConverter<TInner, TKey>, resultSelector?: MaybeAsyncBiConverter<TOuter, TInner, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey>) {
|
||||
constructor(first: AsyncSequence<TOuter>, second: AsyncSequence<TInner>, firstKeySelector: MaybeAsyncConverter<TOuter, TKey>, secondKeySelector: MaybeAsyncConverter<TInner, TKey>, resultSelector?: MaybeAsyncBiConverter<TOuter, TInner, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>) {
|
||||
super();
|
||||
|
||||
this.#first = first;
|
||||
@@ -2132,7 +2182,7 @@ class JoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSequence
|
||||
this.#firstKeySelector = firstKeySelector;
|
||||
this.#secondKeySelector = secondKeySelector;
|
||||
this.#resultSelector = resultSelector ?? identity as MaybeAsyncBiConverter<TOuter, TInner, TResult>;
|
||||
this.#keyComparer = keyComparer ?? strictEquals;
|
||||
this.#keyComparer = keyComparer ? asAsyncEqualityComparer(keyComparer) : defaultAsyncEqualityComparer;
|
||||
}
|
||||
|
||||
override async *iterator() {
|
||||
@@ -2142,7 +2192,7 @@ class JoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSequence
|
||||
for await (const secondObj of this.#second) {
|
||||
const secondKey = await this.#secondKeySelector(secondObj);
|
||||
|
||||
if (await this.#keyComparer(firstKey, secondKey)) {
|
||||
if (await this.#keyComparer.equals(firstKey, secondKey)) {
|
||||
yield await this.#resultSelector(firstObj, secondObj);
|
||||
}
|
||||
}
|
||||
@@ -2156,9 +2206,9 @@ class GroupJoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSeq
|
||||
readonly #firstKeySelector: MaybeAsyncConverter<TOuter, TKey>;
|
||||
readonly #secondKeySelector: MaybeAsyncConverter<TInner, TKey>;
|
||||
readonly #resultSelector: MaybeAsyncBiConverter<TOuter, MaybeAsyncIterable<TInner>, TResult>;
|
||||
readonly #keyComparer: MaybeAsyncEqualityComparison<TKey>;
|
||||
readonly #keyComparer: AsyncEqualityComparer<TKey>;
|
||||
|
||||
constructor(first: AsyncSequence<TOuter>, second: AsyncSequence<TInner>, firstKeySelector: MaybeAsyncConverter<TOuter, TKey>, secondKeySelector: MaybeAsyncConverter<TInner, TKey>, resultSelector?: MaybeAsyncBiConverter<TOuter, MaybeAsyncIterable<TInner>, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey>) {
|
||||
constructor(first: AsyncSequence<TOuter>, second: AsyncSequence<TInner>, firstKeySelector: MaybeAsyncConverter<TOuter, TKey>, secondKeySelector: MaybeAsyncConverter<TInner, TKey>, resultSelector?: MaybeAsyncBiConverter<TOuter, MaybeAsyncIterable<TInner>, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>) {
|
||||
super();
|
||||
|
||||
this.#first = first;
|
||||
@@ -2166,7 +2216,7 @@ class GroupJoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSeq
|
||||
this.#firstKeySelector = firstKeySelector;
|
||||
this.#secondKeySelector = secondKeySelector;
|
||||
this.#resultSelector = resultSelector ?? GroupJoinAsyncSequence.#defaultResultSelector as MaybeAsyncBiConverter<TOuter, MaybeAsyncIterable<TInner>, TResult>;
|
||||
this.#keyComparer = keyComparer ?? strictEquals;
|
||||
this.#keyComparer = keyComparer ? asAsyncEqualityComparer(keyComparer) : defaultAsyncEqualityComparer;
|
||||
}
|
||||
|
||||
static #defaultResultSelector<TOuter, TInner>(first: TOuter, second: AsyncSequence<TInner>) {
|
||||
@@ -2181,7 +2231,7 @@ class GroupJoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSeq
|
||||
for await (const secondObj of this.#second) {
|
||||
const secondKey = await this.#secondKeySelector(secondObj);
|
||||
|
||||
if (await this.#keyComparer(firstKey, secondKey)) {
|
||||
if (await this.#keyComparer.equals(firstKey, secondKey)) {
|
||||
secondObjs.push(secondObj);
|
||||
}
|
||||
}
|
||||
@@ -2195,22 +2245,22 @@ class RemoveAsyncSequence<T> extends BaseAsyncSequence<T> {
|
||||
readonly #sequence: AsyncSequence<T>;
|
||||
readonly #obj: T;
|
||||
readonly #all: boolean;
|
||||
readonly #equater: MaybeAsyncEqualityComparison<T>;
|
||||
readonly #equater: AsyncEqualityComparer<T>;
|
||||
|
||||
constructor(sequence: AsyncSequence<T>, obj: T, all?: boolean, equater?: MaybeAsyncEqualityComparison<T>) {
|
||||
constructor(sequence: AsyncSequence<T>, obj: T, all?: boolean, equater?: MaybeAsyncEqualityComparisonOrComparer<T>) {
|
||||
super();
|
||||
|
||||
this.#sequence = sequence;
|
||||
this.#obj = obj;
|
||||
this.#all = all ?? false;
|
||||
this.#equater = equater ?? strictEquals;
|
||||
this.#equater = equater ? asAsyncEqualityComparer(equater) : defaultAsyncEqualityComparer;
|
||||
}
|
||||
|
||||
override async *iterator() {
|
||||
let gotOne = false;
|
||||
|
||||
for await (const obj of this.#sequence) {
|
||||
if (await this.#equater(this.#obj, obj)) {
|
||||
if (await this.#equater.equals(this.#obj, obj)) {
|
||||
if (this.#all) {
|
||||
continue;
|
||||
}
|
||||
@@ -2254,13 +2304,13 @@ class CacheAsyncSequence<T> extends BaseAsyncSequence<T> {
|
||||
|
||||
class PartitionAsyncSequence<T> extends BaseAsyncSequence<AsyncSequence<T>> {
|
||||
readonly #sequence: AsyncSequence<T>;
|
||||
readonly #equater: MaybeAsyncEqualityComparison<T>;
|
||||
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<T> | undefined;
|
||||
|
||||
constructor(sequence: AsyncSequence<T>, equater: MaybeAsyncEqualityComparison<T> | undefined) {
|
||||
constructor(sequence: AsyncSequence<T>, equater: MaybeAsyncEqualityComparisonOrComparer<T> | undefined) {
|
||||
super();
|
||||
|
||||
this.#sequence = sequence;
|
||||
this.#equater = equater ?? strictEquals;
|
||||
this.#equater = equater;
|
||||
}
|
||||
|
||||
override async *iterator() {
|
||||
@@ -2285,14 +2335,14 @@ class PartitionAsyncSequence<T> extends BaseAsyncSequence<AsyncSequence<T>> {
|
||||
class PartitionByAsyncSequence<TElement, TBy> extends BaseAsyncSequence<AsyncSequence<TElement>> {
|
||||
readonly #sequence: AsyncSequence<TElement>;
|
||||
readonly #selector: MaybeAsyncConverter<TElement, TBy>;
|
||||
readonly #equater: MaybeAsyncEqualityComparison<TBy>;
|
||||
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined;
|
||||
|
||||
constructor(sequence: AsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater: MaybeAsyncEqualityComparison<TBy> | undefined) {
|
||||
constructor(sequence: AsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined) {
|
||||
super();
|
||||
|
||||
this.#sequence = sequence;
|
||||
this.#selector = selector;
|
||||
this.#equater = equater ?? strictEquals;
|
||||
this.#equater = equater;
|
||||
}
|
||||
|
||||
override async *iterator() {
|
||||
|
||||
@@ -2,13 +2,17 @@ import { wrap as wrapSync } from "../sync/index.js";
|
||||
import { Sequence } from "../sync/types.js";
|
||||
import { MaybeAsyncGenerator, MaybeAsyncIterable, MaybePromiseLike } from "../types.js";
|
||||
import { isAsyncIterable } from "../utils.js";
|
||||
import { WrappedSequence, WrappedAsyncIterable, WrappedObjectAsync, WrappedArrayAsync, WrappedArrayLikeAsync, FunctionAsyncSequence, GeneratorAsyncSequence, RangeAsyncSequence, RepeatForeverAsyncSequence, RepeatAsyncSequence, AsyncSequenceMarker, EMPTY, ConcatAsyncSequence } from "./impl.js";
|
||||
import { WrappedSequence, WrappedAsyncIterable, WrappedObjectAsync, WrappedArrayAsync, WrappedArrayLikeAsync, FunctionAsyncSequence, GeneratorAsyncSequence, RangeAsyncSequence, RepeatForeverAsyncSequence, RepeatAsyncSequence, AsyncSequenceMarker, EMPTY, ConcatAsyncSequence, WrappedPromise } from "./impl.js";
|
||||
import { AsyncSequence } from "./types.js";
|
||||
|
||||
export function asAsync<T>(sequence: Sequence<MaybePromiseLike<T>>): AsyncSequence<T> {
|
||||
return new WrappedSequence(sequence);
|
||||
}
|
||||
|
||||
export function wrapPromise<T>(promise: Promise<MaybeAsyncIterable<T>>): AsyncSequence<T> {
|
||||
return new WrappedPromise(promise);
|
||||
}
|
||||
|
||||
export function wrap<T>(iterable: MaybeAsyncIterable<MaybePromiseLike<T>>): AsyncSequence<T> {
|
||||
if (isAsyncSequence<T>(iterable)) {
|
||||
return iterable;
|
||||
|
||||
@@ -1,10 +1,11 @@
|
||||
import { Collector } from "../collector/types.js";
|
||||
import { MaybeAsyncComparisonOrComparer, AsyncComparer } from "../comparer/types.js";
|
||||
import { MaybeAsyncEqualityComparison } from "../equality-comparer/types.js";
|
||||
import { MaybeAsyncEqualityComparisonOrComparer } from "../equality-comparer/types.js";
|
||||
import { AsyncRandomOptions } from "../random/types.js";
|
||||
import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncAction, MaybeAsyncFunction, MaybePromise, MaybeAsyncIterable } from "../types.js";
|
||||
|
||||
export type AsyncSequencePipeline<TElement, TResult> = MaybeAsyncFunction<(sequence: AsyncSequence<TElement>) => TResult>;
|
||||
export type AsyncSequenceElement<TAsyncSequence extends AsyncSequence<any>> = TAsyncSequence extends AsyncSequence<infer TElement> ? TElement : never;
|
||||
|
||||
export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
|
||||
iterator(): AsyncIterator<TElement>;
|
||||
@@ -22,24 +23,24 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
|
||||
where<TFiltered extends TElement>(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TFiltered>;
|
||||
where(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement>;
|
||||
|
||||
groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
|
||||
groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
|
||||
groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
|
||||
groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
|
||||
|
||||
join<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<[TElement, TOther]>;
|
||||
join<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<TResult>;
|
||||
join<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>): AsyncSequence<[TElement, TOther]>;
|
||||
join<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>): AsyncSequence<TResult>;
|
||||
|
||||
groupJoin<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
|
||||
groupJoin<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, MaybeAsyncIterable<TOther>, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<TResult>;
|
||||
groupJoin<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
|
||||
groupJoin<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, MaybeAsyncIterable<TOther>, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>): AsyncSequence<TResult>;
|
||||
|
||||
contains(obj: TElement, equater?: MaybeAsyncEqualityComparison<TElement>): Promise<boolean>;
|
||||
contains(obj: TElement, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): Promise<boolean>;
|
||||
|
||||
sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): Promise<boolean>;
|
||||
sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): Promise<boolean>;
|
||||
|
||||
append(obj: TElement): AsyncSequence<TElement>;
|
||||
|
||||
prepend(obj: TElement): AsyncSequence<TElement>;
|
||||
|
||||
remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>;
|
||||
remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement>;
|
||||
|
||||
concat(...sequences: MaybeAsyncIterable<TElement>[]): AsyncSequence<TElement>;
|
||||
|
||||
@@ -68,26 +69,26 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
|
||||
bounds(comparer?: MaybeAsyncComparisonOrComparer<TElement>): Promise<[min: TElement, max: TElement]>;
|
||||
boundsBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): Promise<[min: TElement, max: TElement]>;
|
||||
|
||||
order(comparer?: MaybeAsyncComparisonOrComparer<TElement>): AsyncSequence<TElement>;
|
||||
orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): AsyncSequence<TElement>;
|
||||
order(comparer?: MaybeAsyncComparisonOrComparer<TElement>): OrderedAsyncSequence<TElement>;
|
||||
orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): OrderedAsyncSequence<TElement>;
|
||||
|
||||
orderDescending(comparer?: MaybeAsyncComparisonOrComparer<TElement>): AsyncSequence<TElement>;
|
||||
orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): AsyncSequence<TElement>;
|
||||
orderDescending(comparer?: MaybeAsyncComparisonOrComparer<TElement>): OrderedAsyncSequence<TElement>;
|
||||
orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): OrderedAsyncSequence<TElement>;
|
||||
|
||||
partition(equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<AsyncSequence<TElement>>;
|
||||
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<AsyncSequence<TElement>>;
|
||||
partition(equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<AsyncSequence<TElement>>;
|
||||
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<AsyncSequence<TElement>>;
|
||||
|
||||
distinct(equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>;
|
||||
distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement>;
|
||||
distinct(equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement>;
|
||||
distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<TElement>;
|
||||
|
||||
union(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>;
|
||||
unionBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement>;
|
||||
union(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement>;
|
||||
unionBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<TElement>;
|
||||
|
||||
except(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>;
|
||||
exceptBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement>;
|
||||
except(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement>;
|
||||
exceptBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<TElement>;
|
||||
|
||||
intersect(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>;
|
||||
intersectBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement>;
|
||||
intersect(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement>;
|
||||
intersectBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<TElement>;
|
||||
|
||||
all(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
|
||||
any(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
|
||||
@@ -108,6 +109,7 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
|
||||
forEach(action: MaybeAsyncAction<TElement>): Promise<void>;
|
||||
|
||||
zip<TOther>(sequence: MaybeAsyncIterable<TOther>): AsyncSequence<[TElement, TOther]>;
|
||||
cartesianProduct<TOther>(sequence: MaybeAsyncIterable<TOther>): AsyncSequence<[TElement, TOther]>;
|
||||
|
||||
indexed(): AsyncSequence<[number, TElement]>;
|
||||
|
||||
|
||||
@@ -2,17 +2,18 @@ import { asArray } from "../utils.js";
|
||||
import { EmptyBitArray, BitArrayImpl } from "./impl.js";
|
||||
import { BitArray } from "./types.js";
|
||||
|
||||
export const EMPTY = new EmptyBitArray();
|
||||
namespace BitArray {
|
||||
export const EMPTY: BitArray = new EmptyBitArray();
|
||||
|
||||
export function create(length: number): BitArray {
|
||||
export function create(length: number): BitArray {
|
||||
if (length < 0) {
|
||||
throw new Error("length < 0");
|
||||
}
|
||||
|
||||
return length === 0 ? EMPTY : new BitArrayImpl(length);
|
||||
}
|
||||
}
|
||||
|
||||
export function from(bits: Iterable<boolean>): BitArray {
|
||||
export function from(bits: Iterable<boolean>) {
|
||||
const arr = asArray(bits);
|
||||
const result = create(arr.length);
|
||||
|
||||
@@ -21,8 +22,27 @@ export function from(bits: Iterable<boolean>): BitArray {
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
export function of(...bits: boolean[]) {
|
||||
return from(bits);
|
||||
}
|
||||
|
||||
export function and(a: BitArray, b: BitArray) {
|
||||
return a.copy().and(b);
|
||||
}
|
||||
|
||||
export function or(a: BitArray, b: BitArray) {
|
||||
return a.copy().or(b);
|
||||
}
|
||||
|
||||
export function xor(a: BitArray, b: BitArray) {
|
||||
return a.copy().xor(b);
|
||||
}
|
||||
|
||||
export function not(a: BitArray) {
|
||||
return a.copy().not();
|
||||
}
|
||||
}
|
||||
|
||||
export function of(...bits: boolean[]): BitArray {
|
||||
return from(bits);
|
||||
}
|
||||
export { BitArray };
|
||||
|
||||
@@ -1,16 +1,16 @@
|
||||
import { MaybeAsyncConverter } from "../types.js";
|
||||
import { Nullable } from "../utils.js";
|
||||
import { AsyncComparer, MaybeAsyncComparisonOrComparer, Comparer, MaybeAsyncComparison, AsyncComparison } from "./types.js";
|
||||
import { AsyncComparer, AsyncComparison, Comparer, MaybeAsyncComparison, MaybeAsyncComparisonOrComparer } from "./types.js";
|
||||
|
||||
export function isAsyncComparer<T>(obj: any): obj is AsyncComparer<T> {
|
||||
return obj instanceof BaseAsyncComparer;
|
||||
}
|
||||
|
||||
export function asAsyncComparer<T>(comparer: MaybeAsyncComparisonOrComparer<T>): AsyncComparer<T> {
|
||||
return typeof comparer === "function" ? createAsyncComparer(comparer) : isAsyncComparer<T>(comparer) ? comparer : new WrappedAsyncComparer(comparer);
|
||||
return typeof comparer === "function" ? createAsyncComparer(comparer) : isAsyncComparer<T>(comparer) ? comparer : fromSyncComparer(comparer);
|
||||
}
|
||||
|
||||
export function fromSync<T>(comparer: Comparer<T>): AsyncComparer<T> {
|
||||
export function fromSyncComparer<T>(comparer: Comparer<T>): AsyncComparer<T> {
|
||||
return new WrappedAsyncComparer(comparer);
|
||||
}
|
||||
|
||||
@@ -22,8 +22,8 @@ export function createAsyncComparerUsing<T, U>(projection: MaybeAsyncConverter<T
|
||||
return new MappedAsyncComparer(projection, comparison);
|
||||
}
|
||||
|
||||
export function combineNullableAsyncComparers<T>(comparers: Nullable<MaybeAsyncComparisonOrComparer<T>>[]): AsyncComparer<T> | undefined {
|
||||
let result = defaultAsyncComparer;
|
||||
export function combineAsyncComparers<T>(comparers: Iterable<Nullable<MaybeAsyncComparisonOrComparer<T>>>): AsyncComparer<T> | undefined {
|
||||
let result: AsyncComparer<T> = dummyAsyncComparer;
|
||||
|
||||
for (const comparer of comparers) {
|
||||
if (!comparer) {
|
||||
@@ -33,7 +33,7 @@ export function combineNullableAsyncComparers<T>(comparers: Nullable<MaybeAsyncC
|
||||
result = result.then(asAsyncComparer(comparer));
|
||||
}
|
||||
|
||||
return result === defaultAsyncComparer ? undefined : result;
|
||||
return result === dummyAsyncComparer ? undefined : result;
|
||||
}
|
||||
|
||||
export abstract class BaseAsyncComparer<T> implements AsyncComparer<T> {
|
||||
@@ -144,6 +144,24 @@ class ThenAsyncComparer<T> extends BaseAsyncComparer<T> {
|
||||
}
|
||||
}
|
||||
|
||||
const dummyAsyncComparer = new class DummyAsyncComparer extends BaseAsyncComparer<any> {
|
||||
public override async compare(_a: any, _b: any): Promise<number> {
|
||||
return 0;
|
||||
}
|
||||
|
||||
public override then(comparer: AsyncComparer<any>): AsyncComparer<any> {
|
||||
return comparer;
|
||||
}
|
||||
|
||||
public override thenCompare(comparison: MaybeAsyncComparison<any>): AsyncComparer<any> {
|
||||
return createAsyncComparer(comparison);
|
||||
}
|
||||
|
||||
public override thenCompareUsing<U>(projection: MaybeAsyncConverter<any, U>, comparison?: MaybeAsyncComparisonOrComparer<U> | undefined): AsyncComparer<any> {
|
||||
return createAsyncComparerUsing(projection, comparison);
|
||||
}
|
||||
}
|
||||
|
||||
export const defaultAsyncComparer: AsyncComparer<any> = new class DefaultAsyncComparer extends BaseAsyncComparer<any> {
|
||||
public override async compare(a: any, b: any): Promise<number> {
|
||||
if (a === undefined) {
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import { Converter } from "../types.js";
|
||||
import { Nullable } from "../utils.js";
|
||||
import { fromSync } from "./async.js";
|
||||
import { fromSyncComparer } from "./async.js";
|
||||
import { Comparer, ComparisonOrComparer, Comparison, AsyncComparer } from "./types.js";
|
||||
|
||||
export function isComparer<T>(obj: any): obj is Comparer<T> {
|
||||
@@ -15,11 +15,11 @@ export function asComparison<T>(comparer: ComparisonOrComparer<T>) {
|
||||
return typeof comparer === "function" ? comparer : comparer.comparison();
|
||||
}
|
||||
|
||||
export function createComparer<T>(comparison: Comparison<T>): Comparer<T> {
|
||||
export function createComparer<T = any>(comparison: Comparison<T>): Comparer<T> {
|
||||
return new SimpleComparer(comparison);
|
||||
}
|
||||
|
||||
export function createComparerUsing<T, U>(projection: Converter<T, U>, comparison?: ComparisonOrComparer<U>): Comparer<T> {
|
||||
export function createComparerUsing<T = any, U = any>(projection: Converter<T, U>, comparison?: ComparisonOrComparer<U>): Comparer<T> {
|
||||
return new MappedComparer(projection, comparison);
|
||||
}
|
||||
|
||||
@@ -27,8 +27,8 @@ export function reverseComparison<T>(comparison: Comparison<T>): Comparison<T> {
|
||||
return (a, b) => comparison(b, a);
|
||||
}
|
||||
|
||||
export function combineNullableComparers<T>(comparers: Nullable<ComparisonOrComparer<T>>[]) {
|
||||
let result = defaultComparer;
|
||||
export function combineComparers<T>(comparers: Iterable<Nullable<ComparisonOrComparer<T>>>) {
|
||||
let result: Comparer<T> = dummyComparer;
|
||||
|
||||
for (const comparer of comparers) {
|
||||
if (!comparer) {
|
||||
@@ -38,7 +38,7 @@ export function combineNullableComparers<T>(comparers: Nullable<ComparisonOrComp
|
||||
result = result.then(asComparer(comparer));
|
||||
}
|
||||
|
||||
return result === defaultComparer ? undefined : result;
|
||||
return result === dummyComparer ? undefined : result;
|
||||
}
|
||||
|
||||
export abstract class BaseComparer<T> implements Comparer<T> {
|
||||
@@ -67,7 +67,7 @@ export abstract class BaseComparer<T> implements Comparer<T> {
|
||||
}
|
||||
|
||||
public toAsync(): AsyncComparer<T> {
|
||||
return fromSync<T>(this);
|
||||
return fromSyncComparer<T>(this);
|
||||
}
|
||||
|
||||
public nullAwareComparer(): Comparer<Nullable<T>> {
|
||||
@@ -75,6 +75,24 @@ export abstract class BaseComparer<T> implements Comparer<T> {
|
||||
}
|
||||
}
|
||||
|
||||
const dummyComparer = new class DummyComparer extends BaseComparer<any> {
|
||||
public override compare(_a: any, _b: any): number {
|
||||
return 0;
|
||||
}
|
||||
|
||||
public override then(comparer: Comparer<any>): Comparer<any> {
|
||||
return comparer;
|
||||
}
|
||||
|
||||
public override thenCompare(comparison: Comparison<any>): Comparer<any> {
|
||||
return createComparer(comparison);
|
||||
}
|
||||
|
||||
public override thenCompareUsing<U>(projection: Converter<any, U>, comparison?: ComparisonOrComparer<U> | undefined): Comparer<any> {
|
||||
return createComparerUsing(projection, comparison);
|
||||
}
|
||||
};
|
||||
|
||||
class SimpleComparer<T> extends BaseComparer<T> {
|
||||
readonly #comparison: Comparison<T>;
|
||||
|
||||
|
||||
@@ -24,12 +24,9 @@ export interface AsyncComparer<T> {
|
||||
|
||||
export type Comparison<T> = (first: T, second: T) => number;
|
||||
export type ComparisonOrComparer<T> = Comparison<T> | Comparer<T>;
|
||||
export type Equater<T> = (first: T, second: T) => boolean;
|
||||
|
||||
export type AsyncComparison<T> = AsyncFunction<Comparison<T>>;
|
||||
export type MaybeAsyncComparison<T> = MaybeAsyncFunction<Comparison<T>>;
|
||||
export type AsyncComparisonOrComparer<T> = AsyncComparison<T> | AsyncComparer<T>;
|
||||
export type MaybeAsyncComparisonOrComparer<T> = MaybeAsyncComparison<T> | Comparer<T> | AsyncComparer<T>;
|
||||
export type AsyncEquater<T> = AsyncFunction<Equater<T>>;
|
||||
export type MaybeAsyncEquater<T> = MaybeAsyncFunction<Equater<T>>;
|
||||
|
||||
|
||||
217
src/equality-comparer/async.ts
Normal file
217
src/equality-comparer/async.ts
Normal file
@@ -0,0 +1,217 @@
|
||||
import { MaybeAsyncConverter } from "../types.js";
|
||||
import { Nullable } from "../utils.js";
|
||||
import { AsyncEqualityComparer, AsyncEqualityComparison, EqualityComparer, MaybeAsyncEqualityComparison, MaybeAsyncEqualityComparisonOrComparer } from "./types.js";
|
||||
|
||||
export function isAsyncEqualityComparer<T>(obj: any): obj is AsyncEqualityComparer<T> {
|
||||
return obj instanceof BaseAsyncEqualityComparer;
|
||||
}
|
||||
|
||||
export function asAsyncEqualityComparer<T>(equalityComparer: MaybeAsyncEqualityComparisonOrComparer<T>): AsyncEqualityComparer<T> {
|
||||
return typeof equalityComparer === "function" ? createAsyncEqualityComparer(equalityComparer) : isAsyncEqualityComparer<T>(equalityComparer) ? equalityComparer : fromSyncEqualityComparer(equalityComparer);
|
||||
}
|
||||
|
||||
export function fromSyncEqualityComparer<T>(equalityComparer: EqualityComparer<T>): AsyncEqualityComparer<T> {
|
||||
return new WrappedAsyncEqualityComparer(equalityComparer);
|
||||
}
|
||||
|
||||
export function createAsyncEqualityComparer<T = any>(equalityComparison: MaybeAsyncEqualityComparison<T>): AsyncEqualityComparer<T> {
|
||||
return new SimpleAsyncEqualityComparer(equalityComparison);
|
||||
}
|
||||
|
||||
export function createAsyncEqualityComparerUsing<T = any, U = any>(projection: MaybeAsyncConverter<T, U>, equalityComparison?: MaybeAsyncEqualityComparisonOrComparer<U>): AsyncEqualityComparer<T> {
|
||||
return new MappedAsyncEqualityComparer(projection, equalityComparison);
|
||||
}
|
||||
|
||||
export function combineAsyncEqualityComparers<T>(equalityComparers: Iterable<Nullable<MaybeAsyncEqualityComparisonOrComparer<T>>>) {
|
||||
let result: AsyncEqualityComparer<T> = alwaysTrueAsyncEqualityComparer;
|
||||
|
||||
for (const equalityComparer of equalityComparers) {
|
||||
if (!equalityComparer) {
|
||||
continue;
|
||||
}
|
||||
|
||||
result = result.then(asAsyncEqualityComparer(equalityComparer));
|
||||
}
|
||||
|
||||
return result === alwaysTrueAsyncEqualityComparer ? undefined : result;
|
||||
}
|
||||
|
||||
export abstract class BaseAsyncEqualityComparer<T> implements AsyncEqualityComparer<T> {
|
||||
#cachedBoundEqualityComparison: AsyncEqualityComparison<T> | undefined;
|
||||
|
||||
public abstract equals(a: T, b: T): Promise<boolean>;
|
||||
|
||||
public equalityComparison(): AsyncEqualityComparison<T> {
|
||||
return this.#cachedBoundEqualityComparison ??= this.equals.bind(this);
|
||||
}
|
||||
|
||||
public opposite(): AsyncEqualityComparer<T> {
|
||||
return new OppositeAsyncEqualityComparer(this);
|
||||
}
|
||||
|
||||
public then(equalityComparer: AsyncEqualityComparer<T>): AsyncEqualityComparer<T> {
|
||||
return new ThenAsyncEqualityComparer(this, equalityComparer);
|
||||
}
|
||||
|
||||
public thenEquals(equalityComparison: MaybeAsyncEqualityComparison<T>): AsyncEqualityComparer<T> {
|
||||
return this.then(createAsyncEqualityComparer(equalityComparison));
|
||||
}
|
||||
|
||||
public thenEqualsUsing<U>(projection: MaybeAsyncConverter<T, U>, equalityComparison?: MaybeAsyncEqualityComparisonOrComparer<U>): AsyncEqualityComparer<T> {
|
||||
return this.then(createAsyncEqualityComparerUsing(projection, equalityComparison));
|
||||
}
|
||||
}
|
||||
|
||||
class WrappedAsyncEqualityComparer<T> extends BaseAsyncEqualityComparer<T> {
|
||||
readonly #base: EqualityComparer<T>;
|
||||
|
||||
constructor(base: EqualityComparer<T>) {
|
||||
super();
|
||||
|
||||
this.#base = base;
|
||||
}
|
||||
|
||||
public override async equals(a: T, b: T) {
|
||||
return this.#base.equals(a, b);
|
||||
}
|
||||
}
|
||||
|
||||
class SimpleAsyncEqualityComparer<T> extends BaseAsyncEqualityComparer<T> {
|
||||
readonly #equalityComparison: MaybeAsyncEqualityComparison<T>;
|
||||
|
||||
public constructor(equalityComparison: MaybeAsyncEqualityComparison<T>) {
|
||||
super();
|
||||
|
||||
this.#equalityComparison = equalityComparison;
|
||||
}
|
||||
|
||||
public override async equals(a: T, b: T): Promise<boolean> {
|
||||
return await this.#equalityComparison(a, b);
|
||||
}
|
||||
}
|
||||
|
||||
class MappedAsyncEqualityComparer<T, U> extends BaseAsyncEqualityComparer<T> {
|
||||
readonly #projection: MaybeAsyncConverter<T, U>;
|
||||
readonly #equalityComparison: AsyncEqualityComparer<U>;
|
||||
|
||||
public constructor(projection: MaybeAsyncConverter<T, U>, equalityComparison?: MaybeAsyncEqualityComparisonOrComparer<U>) {
|
||||
super();
|
||||
|
||||
this.#projection = projection;
|
||||
this.#equalityComparison = equalityComparison ? asAsyncEqualityComparer(equalityComparison) : defaultAsyncEqualityComparer;
|
||||
}
|
||||
|
||||
public override async equals(a: T, b: T): Promise<boolean> {
|
||||
return await this.#equalityComparison.equals(await this.#projection(a), await this.#projection(b));
|
||||
}
|
||||
}
|
||||
|
||||
class OppositeAsyncEqualityComparer<T> extends BaseAsyncEqualityComparer<T> {
|
||||
readonly #base: AsyncEqualityComparer<T>;
|
||||
|
||||
public constructor(base: AsyncEqualityComparer<T>) {
|
||||
super();
|
||||
|
||||
this.#base = base;
|
||||
}
|
||||
|
||||
public override async equals(a: T, b: T): Promise<boolean> {
|
||||
return !(await this.#base.equals(a, b));
|
||||
}
|
||||
|
||||
public override opposite(): AsyncEqualityComparer<T> {
|
||||
return this.#base;
|
||||
}
|
||||
}
|
||||
|
||||
class ThenAsyncEqualityComparer<T> extends BaseAsyncEqualityComparer<T> {
|
||||
readonly #base: AsyncEqualityComparer<T>;
|
||||
readonly #equalityComparer: AsyncEqualityComparer<T>;
|
||||
|
||||
public constructor(base: AsyncEqualityComparer<T>, equalityComparer: AsyncEqualityComparer<T>) {
|
||||
super();
|
||||
|
||||
this.#base = base;
|
||||
this.#equalityComparer = equalityComparer;
|
||||
}
|
||||
|
||||
public override async equals(a: T, b: T) {
|
||||
return await this.#base.equals(a, b) && await this.#equalityComparer.equals(a, b);
|
||||
}
|
||||
}
|
||||
|
||||
export const alwaysAsyncFalseEqualityComparer = new class AlwaysFalseAsyncEqualityComparer extends BaseAsyncEqualityComparer<any> {
|
||||
public override async equals(_a: any, _b: any): Promise<boolean> {
|
||||
return false;
|
||||
}
|
||||
|
||||
public override opposite(): AsyncEqualityComparer<any> {
|
||||
return alwaysTrueAsyncEqualityComparer;
|
||||
}
|
||||
|
||||
public override then(_equalityComparer: AsyncEqualityComparer<any>): AsyncEqualityComparer<any> {
|
||||
return this;
|
||||
}
|
||||
|
||||
public override thenEquals(_equalityComparison: MaybeAsyncEqualityComparison<any>): AsyncEqualityComparer<any> {
|
||||
return this;
|
||||
}
|
||||
|
||||
public override thenEqualsUsing<U>(_projection: MaybeAsyncConverter<any, U>, _equalityComparison?: MaybeAsyncEqualityComparisonOrComparer<U> | undefined): AsyncEqualityComparer<any> {
|
||||
return this;
|
||||
}
|
||||
};
|
||||
|
||||
export const alwaysTrueAsyncEqualityComparer = new class AlwaysTrueAsyncEqualityComparer extends BaseAsyncEqualityComparer<any> {
|
||||
public override async equals(_a: any, _b: any): Promise<boolean> {
|
||||
return true;
|
||||
}
|
||||
|
||||
public override opposite(): AsyncEqualityComparer<any> {
|
||||
return alwaysAsyncFalseEqualityComparer;
|
||||
}
|
||||
|
||||
public override then(equalityComparer: AsyncEqualityComparer<any>): AsyncEqualityComparer<any> {
|
||||
return equalityComparer;
|
||||
}
|
||||
|
||||
public override thenEquals(equalityComparison: MaybeAsyncEqualityComparison<any>): AsyncEqualityComparer<any> {
|
||||
return createAsyncEqualityComparer(equalityComparison);
|
||||
}
|
||||
|
||||
public override thenEqualsUsing<U>(projection: MaybeAsyncConverter<any, U>, equalityComparison?: MaybeAsyncEqualityComparisonOrComparer<U> | undefined): AsyncEqualityComparer<any> {
|
||||
return createAsyncEqualityComparerUsing(projection, equalityComparison);
|
||||
}
|
||||
};
|
||||
|
||||
export const looseAsyncEqualityComparer: AsyncEqualityComparer<any> = new class LooseAsyncEqualityComparer extends BaseAsyncEqualityComparer<any> {
|
||||
public override async equals(a: any, b: any): Promise<boolean> {
|
||||
return a == b;
|
||||
}
|
||||
};
|
||||
export const strictAsyncEqualityComparer: AsyncEqualityComparer<any> = new class StrictAsyncEqualityComparer extends BaseAsyncEqualityComparer<any> {
|
||||
public override async equals(a: any, b: any): Promise<boolean> {
|
||||
return a === b;
|
||||
}
|
||||
};
|
||||
export const sameValueAsyncEqualityComparer: AsyncEqualityComparer<any> = new class SameValueAsyncEqualityComparer extends BaseAsyncEqualityComparer<any> {
|
||||
public override async equals(a: any, b: any): Promise<boolean> {
|
||||
return Object.is(a, b);
|
||||
}
|
||||
};
|
||||
|
||||
export const defaultAsyncEqualityComparer: AsyncEqualityComparer<any> = new class DefaultAsyncEqualityComparer extends BaseAsyncEqualityComparer<any> {
|
||||
public override async equals(a: any, b: any): Promise<boolean> {
|
||||
return a === b;
|
||||
}
|
||||
};
|
||||
|
||||
export function getDefaultAsyncEqualityComparer<T>(): AsyncEqualityComparer<T> {
|
||||
return defaultAsyncEqualityComparer;
|
||||
}
|
||||
|
||||
export const dateAsyncEqualityComparer: AsyncEqualityComparer<Date> = new class DateAsyncEqualityComparer extends BaseAsyncEqualityComparer<Date> {
|
||||
public override async equals(a: Date, b: Date): Promise<boolean> {
|
||||
return a.getTime() === b.getTime();
|
||||
}
|
||||
};
|
||||
@@ -1,15 +0,0 @@
|
||||
export function identity<T>(obj: T) {
|
||||
return obj;
|
||||
}
|
||||
|
||||
export function looseEquals<T>(a: T, b: T) {
|
||||
return a == b;
|
||||
}
|
||||
|
||||
export function strictEquals<T>(a: T, b: T) {
|
||||
return a === b;
|
||||
}
|
||||
|
||||
export function sameValue<T>(a: T, b: T) {
|
||||
return Object.is(a, b);
|
||||
}
|
||||
203
src/equality-comparer/sync.ts
Normal file
203
src/equality-comparer/sync.ts
Normal file
@@ -0,0 +1,203 @@
|
||||
import { Converter } from "../types.js";
|
||||
import { Nullable } from "../utils.js";
|
||||
import { EqualityComparer, EqualityComparison, EqualityComparisonOrComparer } from "./types.js";
|
||||
|
||||
export function isEqualityComparer<T>(obj: any): obj is EqualityComparer<T> {
|
||||
return obj instanceof BaseEqualityComparer;
|
||||
}
|
||||
|
||||
export function asEqualityComparer<T>(equalityComparer: EqualityComparisonOrComparer<T>): EqualityComparer<T> {
|
||||
return typeof equalityComparer === "function" ? createEqualityComparer(equalityComparer) : equalityComparer;
|
||||
}
|
||||
|
||||
export function createEqualityComparer<T = any>(equalityComparison: EqualityComparison<T>): EqualityComparer<T> {
|
||||
return new SimpleEqualityComparer(equalityComparison);
|
||||
}
|
||||
|
||||
export function createEqualityComparerUsing<T = any, U = any>(projection: Converter<T, U>, equalityComparison?: EqualityComparisonOrComparer<U>): EqualityComparer<T> {
|
||||
return new MappedEqualityComparer(projection, equalityComparison);
|
||||
}
|
||||
|
||||
export function combineEqualityComparers<T>(equalityComparers: Iterable<Nullable<EqualityComparisonOrComparer<T>>>) {
|
||||
let result: EqualityComparer<T> = alwaysTrueEqualityComparer;
|
||||
|
||||
for (const equalityComparer of equalityComparers) {
|
||||
if (!equalityComparer) {
|
||||
continue;
|
||||
}
|
||||
|
||||
result = result.then(asEqualityComparer(equalityComparer));
|
||||
}
|
||||
|
||||
return result === alwaysTrueEqualityComparer ? undefined : result;
|
||||
}
|
||||
|
||||
export abstract class BaseEqualityComparer<T> implements EqualityComparer<T> {
|
||||
#cachedBoundEqualityComparison: EqualityComparison<T> | undefined;
|
||||
|
||||
public abstract equals(a: T, b: T): boolean;
|
||||
|
||||
public equalityComparison(): EqualityComparison<T> {
|
||||
return this.#cachedBoundEqualityComparison ??= this.equals.bind(this);
|
||||
}
|
||||
|
||||
public opposite(): EqualityComparer<T> {
|
||||
return new OppositeEqualityComparer(this);
|
||||
}
|
||||
|
||||
public then(equalityComparer: EqualityComparer<T>): EqualityComparer<T> {
|
||||
return new ThenEqualityComparer(this, equalityComparer);
|
||||
}
|
||||
|
||||
public thenEquals(equalityComparison: EqualityComparison<T>): EqualityComparer<T> {
|
||||
return this.then(createEqualityComparer(equalityComparison));
|
||||
}
|
||||
|
||||
public thenEqualsUsing<U>(projection: Converter<T, U>, equalityComparison?: EqualityComparisonOrComparer<U>): EqualityComparer<T> {
|
||||
return this.then(createEqualityComparerUsing(projection, equalityComparison));
|
||||
}
|
||||
}
|
||||
|
||||
class SimpleEqualityComparer<T> extends BaseEqualityComparer<T> {
|
||||
readonly #equalityComparison: EqualityComparison<T>;
|
||||
|
||||
public constructor(equalityComparison: EqualityComparison<T>) {
|
||||
super();
|
||||
|
||||
this.#equalityComparison = equalityComparison;
|
||||
}
|
||||
|
||||
public override equals(a: T, b: T): boolean {
|
||||
return this.#equalityComparison(a, b);
|
||||
}
|
||||
|
||||
public override equalityComparison() {
|
||||
return this.#equalityComparison;
|
||||
}
|
||||
}
|
||||
|
||||
class MappedEqualityComparer<T, U> extends BaseEqualityComparer<T> {
|
||||
readonly #projection: Converter<T, U>;
|
||||
readonly #equalityComparison: EqualityComparer<U>;
|
||||
|
||||
public constructor(projection: Converter<T, U>, equalityComparison?: EqualityComparisonOrComparer<U>) {
|
||||
super();
|
||||
|
||||
this.#projection = projection;
|
||||
this.#equalityComparison = equalityComparison ? asEqualityComparer(equalityComparison) : defaultEqualityComparer;
|
||||
}
|
||||
|
||||
public override equals(a: T, b: T): boolean {
|
||||
return this.#equalityComparison.equals(this.#projection(a), this.#projection(b));
|
||||
}
|
||||
}
|
||||
|
||||
class OppositeEqualityComparer<T> extends BaseEqualityComparer<T> {
|
||||
readonly #base: EqualityComparer<T>;
|
||||
|
||||
public constructor(base: EqualityComparer<T>) {
|
||||
super();
|
||||
|
||||
this.#base = base;
|
||||
}
|
||||
|
||||
public override equals(a: T, b: T): boolean {
|
||||
return !this.#base.equals(a, b);
|
||||
}
|
||||
|
||||
public override opposite(): EqualityComparer<T> {
|
||||
return this.#base;
|
||||
}
|
||||
}
|
||||
|
||||
class ThenEqualityComparer<T> extends BaseEqualityComparer<T> {
|
||||
readonly #base: EqualityComparer<T>;
|
||||
readonly #equalityComparer: EqualityComparer<T>;
|
||||
|
||||
public constructor(base: EqualityComparer<T>, equalityComparer: EqualityComparer<T>) {
|
||||
super();
|
||||
|
||||
this.#base = base;
|
||||
this.#equalityComparer = equalityComparer;
|
||||
}
|
||||
|
||||
public override equals(a: T, b: T) {
|
||||
return this.#base.equals(a, b) && this.#equalityComparer.equals(a, b);
|
||||
}
|
||||
}
|
||||
|
||||
export const alwaysFalseEqualityComparer = new class AlwaysFalseEqualityComparer extends BaseEqualityComparer<any> {
|
||||
public override equals(_a: any, _b: any): boolean {
|
||||
return false;
|
||||
}
|
||||
|
||||
public override opposite(): EqualityComparer<any> {
|
||||
return alwaysTrueEqualityComparer;
|
||||
}
|
||||
|
||||
public override then(_equalityComparer: EqualityComparer<any>): EqualityComparer<any> {
|
||||
return this;
|
||||
}
|
||||
|
||||
public override thenEquals(_equalityComparison: EqualityComparison<any>): EqualityComparer<any> {
|
||||
return this;
|
||||
}
|
||||
|
||||
public override thenEqualsUsing<U>(_projection: Converter<any, U>, _equalityComparison?: EqualityComparisonOrComparer<U> | undefined): EqualityComparer<any> {
|
||||
return this;
|
||||
}
|
||||
};
|
||||
|
||||
export const alwaysTrueEqualityComparer = new class AlwaysTrueEqualityComparer extends BaseEqualityComparer<any> {
|
||||
public override equals(_a: any, _b: any): boolean {
|
||||
return true;
|
||||
}
|
||||
|
||||
public override opposite(): EqualityComparer<any> {
|
||||
return alwaysFalseEqualityComparer;
|
||||
}
|
||||
|
||||
public override then(equalityComparer: EqualityComparer<any>): EqualityComparer<any> {
|
||||
return equalityComparer;
|
||||
}
|
||||
|
||||
public override thenEquals(equalityComparison: EqualityComparison<any>): EqualityComparer<any> {
|
||||
return createEqualityComparer(equalityComparison);
|
||||
}
|
||||
|
||||
public override thenEqualsUsing<U>(projection: Converter<any, U>, equalityComparison?: EqualityComparisonOrComparer<U> | undefined): EqualityComparer<any> {
|
||||
return createEqualityComparerUsing(projection, equalityComparison);
|
||||
}
|
||||
};
|
||||
|
||||
export const looseEqualityComparer: EqualityComparer<any> = new class LooseEqualityComparer extends BaseEqualityComparer<any> {
|
||||
public override equals(a: any, b: any): boolean {
|
||||
return a == b;
|
||||
}
|
||||
};
|
||||
export const strictEqualityComparer: EqualityComparer<any> = new class StrictEqualityComparer extends BaseEqualityComparer<any> {
|
||||
public override equals(a: any, b: any): boolean {
|
||||
return a === b;
|
||||
}
|
||||
};
|
||||
export const sameValueEqualityComparer: EqualityComparer<any> = new class SameValueEqualityComparer extends BaseEqualityComparer<any> {
|
||||
public override equals(a: any, b: any): boolean {
|
||||
return Object.is(a, b);
|
||||
}
|
||||
};
|
||||
|
||||
export const defaultEqualityComparer: EqualityComparer<any> = new class DefaultEqualityComparer extends BaseEqualityComparer<any> {
|
||||
public override equals(a: any, b: any): boolean {
|
||||
return a === b;
|
||||
}
|
||||
};
|
||||
|
||||
export function getDefaultEqualityComparer<T>(): EqualityComparer<T> {
|
||||
return defaultEqualityComparer;
|
||||
}
|
||||
|
||||
export const dateEqualityComparer: EqualityComparer<Date> = new class DateEqualityComparer extends BaseEqualityComparer<Date> {
|
||||
public override equals(a: Date, b: Date): boolean {
|
||||
return a.getTime() === b.getTime();
|
||||
}
|
||||
};
|
||||
@@ -1,6 +1,28 @@
|
||||
import { AsyncFunction, MaybeAsyncFunction } from "../types.js";
|
||||
import { AsyncFunction, Converter, MaybeAsyncConverter, MaybeAsyncFunction } from "../types.js";
|
||||
|
||||
export interface EqualityComparer<T> {
|
||||
equals(a: T, b: T): boolean;
|
||||
equalityComparison(): EqualityComparison<T>;
|
||||
opposite(): EqualityComparer<T>;
|
||||
then(equalityComparer: EqualityComparer<T>): EqualityComparer<T>;
|
||||
thenEquals(equalityComparison: EqualityComparison<T>): EqualityComparer<T>;
|
||||
thenEqualsUsing<U>(projection: Converter<T, U>, equalityComparison?: EqualityComparisonOrComparer<U>): EqualityComparer<T>;
|
||||
}
|
||||
|
||||
export interface AsyncEqualityComparer<T> {
|
||||
equals(a: T, b: T): Promise<boolean>;
|
||||
equalityComparison(): AsyncEqualityComparison<T>;
|
||||
opposite(): AsyncEqualityComparer<T>;
|
||||
then(equalityComparer: AsyncEqualityComparer<T>): AsyncEqualityComparer<T>;
|
||||
thenEquals(equalityComparison: AsyncEqualityComparison<T>): AsyncEqualityComparer<T>;
|
||||
thenEqualsUsing<U>(projection: MaybeAsyncConverter<T, U>, equalityComparison?: AsyncEqualityComparisonOrComparer<U>): AsyncEqualityComparer<T>;
|
||||
}
|
||||
|
||||
export type EqualityComparison<T> = (first: T, second: T) => boolean;
|
||||
export type EqualityComparisonOrComparer<T> = EqualityComparison<T> | EqualityComparer<T>;
|
||||
|
||||
export type AsyncEqualityComparison<T> = AsyncFunction<EqualityComparison<T>>;
|
||||
export type MaybeAsyncEqualityComparison<T> = MaybeAsyncFunction<EqualityComparison<T>>;
|
||||
export type AsyncEqualityComparisonOrComparer<T> = AsyncEqualityComparison<T> | AsyncEqualityComparer<T>;
|
||||
export type MaybeAsyncEqualityComparisonOrComparer<T> = MaybeAsyncEqualityComparison<T> | EqualityComparer<T> | AsyncEqualityComparer<T>;
|
||||
|
||||
|
||||
@@ -1,22 +1,10 @@
|
||||
import { EqualityComparison, MaybeAsyncEqualityComparison } from "./equality-comparer/types.js";
|
||||
import { MaybeAsyncIterable } from "./types.js";
|
||||
import { asAsyncEqualityComparer } from "../equality-comparer/async.js";
|
||||
import { asEqualityComparer } from "../equality-comparer/sync.js";
|
||||
import { AsyncEqualityComparer, EqualityComparer, EqualityComparisonOrComparer, MaybeAsyncEqualityComparisonOrComparer } from "../equality-comparer/types.js";
|
||||
import { MaybeAsyncIterable } from "../types.js";
|
||||
import { AsyncEqualityMap, EqualityMap, EqualityMapEntry } from "./types.js";
|
||||
|
||||
export type Entry<K, V> = [key: K, value: V];
|
||||
|
||||
export interface EqualityMap<K, V> extends Iterable<Entry<K, V>> {
|
||||
readonly size: number;
|
||||
get(key: K): V | undefined;
|
||||
set(key: K, value: V): V | undefined;
|
||||
setAll(entries: Iterable<Entry<K, V>>): void;
|
||||
contains(key: K): boolean;
|
||||
remove(key: K): V | undefined;
|
||||
clear(): void;
|
||||
keys(): IterableIterator<K>;
|
||||
values(): IterableIterator<V>;
|
||||
entries(): IterableIterator<Entry<K, V>>;
|
||||
}
|
||||
|
||||
class NativeEqualityMap<K, V> implements EqualityMap<K, V> {
|
||||
export class NativeEqualityMap<K, V> implements EqualityMap<K, V> {
|
||||
readonly #map = new Map<K, V>();
|
||||
|
||||
get size() {
|
||||
@@ -33,7 +21,7 @@ class NativeEqualityMap<K, V> implements EqualityMap<K, V> {
|
||||
return existing;
|
||||
}
|
||||
|
||||
setAll(entries: Iterable<Entry<K, V>>) {
|
||||
setAll(entries: Iterable<EqualityMapEntry<K, V>>) {
|
||||
for (const [key, value] of entries) {
|
||||
this.set(key, value);
|
||||
}
|
||||
@@ -70,12 +58,12 @@ class NativeEqualityMap<K, V> implements EqualityMap<K, V> {
|
||||
}
|
||||
}
|
||||
|
||||
class CustomEqualityMap<K, V> implements EqualityMap<K, V> {
|
||||
readonly #list: Entry<K, V>[] = [];
|
||||
readonly #keyComparer: EqualityComparison<K>;
|
||||
export class CustomEqualityMap<K, V> implements EqualityMap<K, V> {
|
||||
readonly #list: EqualityMapEntry<K, V>[] = [];
|
||||
readonly #keyComparer: EqualityComparer<K>;
|
||||
|
||||
constructor(keyComparer: EqualityComparison<K>) {
|
||||
this.#keyComparer = keyComparer;
|
||||
constructor(keyComparer: EqualityComparisonOrComparer<K>) {
|
||||
this.#keyComparer = asEqualityComparer(keyComparer);
|
||||
}
|
||||
|
||||
get size() {
|
||||
@@ -84,7 +72,7 @@ class CustomEqualityMap<K, V> implements EqualityMap<K, V> {
|
||||
|
||||
get(key: K) {
|
||||
for (const entry of this.#list) {
|
||||
if (this.#keyComparer(key, entry[0])) {
|
||||
if (this.#keyComparer.equals(key, entry[0])) {
|
||||
return entry[1];
|
||||
}
|
||||
}
|
||||
@@ -94,7 +82,7 @@ class CustomEqualityMap<K, V> implements EqualityMap<K, V> {
|
||||
|
||||
set(key: K, value: V) {
|
||||
for (const entry of this.#list) {
|
||||
if (this.#keyComparer(key, entry[0])) {
|
||||
if (this.#keyComparer.equals(key, entry[0])) {
|
||||
const previous = entry[1];
|
||||
entry[1] = value;
|
||||
return previous;
|
||||
@@ -106,7 +94,7 @@ class CustomEqualityMap<K, V> implements EqualityMap<K, V> {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
setAll(entries: Iterable<Entry<K, V>>) {
|
||||
setAll(entries: Iterable<EqualityMapEntry<K, V>>) {
|
||||
for (const [key, value] of entries) {
|
||||
this.set(key, value);
|
||||
}
|
||||
@@ -114,7 +102,7 @@ class CustomEqualityMap<K, V> implements EqualityMap<K, V> {
|
||||
|
||||
contains(key: K) {
|
||||
for (const entry of this.#list) {
|
||||
if (this.#keyComparer(key, entry[0])) {
|
||||
if (this.#keyComparer.equals(key, entry[0])) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -124,7 +112,7 @@ class CustomEqualityMap<K, V> implements EqualityMap<K, V> {
|
||||
|
||||
remove(key: K) {
|
||||
for (let i = 0; i < this.#list.length; i++) {
|
||||
if (this.#keyComparer(key, this.#list[i][0])) {
|
||||
if (this.#keyComparer.equals(key, this.#list[i][0])) {
|
||||
const removed = this.#list.splice(i, 1);
|
||||
return removed[0][1];
|
||||
}
|
||||
@@ -155,29 +143,12 @@ class CustomEqualityMap<K, V> implements EqualityMap<K, V> {
|
||||
|
||||
*[Symbol.iterator]() {
|
||||
for (const entry of this.#list) {
|
||||
yield entry.slice() as Entry<K, V>; // no entry mutation allowed!
|
||||
yield entry.slice() as EqualityMapEntry<K, V>; // no entry mutation allowed!
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export function createEqualityMap<K, V>(keyComparer?: EqualityComparison<K>): EqualityMap<K, V> {
|
||||
return keyComparer ? new CustomEqualityMap<K, V>(keyComparer) : new NativeEqualityMap<K, V>();
|
||||
}
|
||||
|
||||
export interface AsyncEqualityMap<K, V> extends Iterable<Entry<K, V>> {
|
||||
readonly size: number;
|
||||
get(key: K): Promise<V | undefined>;
|
||||
set(key: K, value: V): Promise<V | undefined>;
|
||||
setAll(entries: MaybeAsyncIterable<Entry<K, V>>): Promise<void>;
|
||||
contains(key: K): Promise<boolean>;
|
||||
remove(key: K): Promise<V | undefined>;
|
||||
clear(): void;
|
||||
keys(): IterableIterator<K>;
|
||||
values(): IterableIterator<V>;
|
||||
entries(): IterableIterator<Entry<K, V>>;
|
||||
}
|
||||
|
||||
class NativeAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
|
||||
export class NativeAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
|
||||
readonly #map = new Map<K, V>();
|
||||
|
||||
get size() {
|
||||
@@ -194,7 +165,7 @@ class NativeAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
|
||||
return existing;
|
||||
}
|
||||
|
||||
async setAll(entries: MaybeAsyncIterable<Entry<K, V>>) {
|
||||
async setAll(entries: MaybeAsyncIterable<EqualityMapEntry<K, V>>) {
|
||||
for await (const [key, value] of entries) {
|
||||
await this.set(key, value);
|
||||
}
|
||||
@@ -231,12 +202,12 @@ class NativeAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
|
||||
}
|
||||
}
|
||||
|
||||
class CustomAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
|
||||
readonly #list: Entry<K, V>[] = [];
|
||||
readonly #keyComparer: MaybeAsyncEqualityComparison<K>;
|
||||
export class CustomAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
|
||||
readonly #list: EqualityMapEntry<K, V>[] = [];
|
||||
readonly #keyComparer: AsyncEqualityComparer<K>;
|
||||
|
||||
constructor(keyComparer: MaybeAsyncEqualityComparison<K>) {
|
||||
this.#keyComparer = keyComparer;
|
||||
constructor(keyComparer: MaybeAsyncEqualityComparisonOrComparer<K>) {
|
||||
this.#keyComparer = asAsyncEqualityComparer(keyComparer);
|
||||
}
|
||||
|
||||
get size() {
|
||||
@@ -245,7 +216,7 @@ class CustomAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
|
||||
|
||||
async get(key: K) {
|
||||
for (const entry of this.#list) {
|
||||
if (await this.#keyComparer(key, entry[0])) {
|
||||
if (await this.#keyComparer.equals(key, entry[0])) {
|
||||
return entry[1];
|
||||
}
|
||||
}
|
||||
@@ -255,7 +226,7 @@ class CustomAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
|
||||
|
||||
async set(key: K, value: V) {
|
||||
for (const entry of this.#list) {
|
||||
if (await this.#keyComparer(key, entry[0])) {
|
||||
if (await this.#keyComparer.equals(key, entry[0])) {
|
||||
const previous = entry[1];
|
||||
entry[1] = value;
|
||||
return previous;
|
||||
@@ -267,7 +238,7 @@ class CustomAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
async setAll(entries: MaybeAsyncIterable<Entry<K, V>>) {
|
||||
async setAll(entries: MaybeAsyncIterable<EqualityMapEntry<K, V>>) {
|
||||
for await (const [key, value] of entries) {
|
||||
await this.set(key, value);
|
||||
}
|
||||
@@ -275,7 +246,7 @@ class CustomAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
|
||||
|
||||
async contains(key: K) {
|
||||
for (const entry of this.#list) {
|
||||
if (await this.#keyComparer(key, entry[0])) {
|
||||
if (await this.#keyComparer.equals(key, entry[0])) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -285,7 +256,7 @@ class CustomAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
|
||||
|
||||
async remove(key: K) {
|
||||
for (let i = 0; i < this.#list.length; i++) {
|
||||
if (await this.#keyComparer(key, this.#list[i][0])) {
|
||||
if (await this.#keyComparer.equals(key, this.#list[i][0])) {
|
||||
const removed = this.#list.splice(i, 1);
|
||||
return removed[0][1];
|
||||
}
|
||||
@@ -316,11 +287,7 @@ class CustomAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
|
||||
|
||||
*[Symbol.iterator]() {
|
||||
for (const entry of this.#list) {
|
||||
yield entry.slice() as Entry<K, V>; // no entry mutation allowed!
|
||||
yield entry.slice() as EqualityMapEntry<K, V>; // no entry mutation allowed!
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export function createAsyncEqualityMap<K, V>(keyComparer?: MaybeAsyncEqualityComparison<K>): AsyncEqualityMap<K, V> {
|
||||
return keyComparer ? new CustomAsyncEqualityMap<K, V>(keyComparer) : new NativeAsyncEqualityMap<K, V>();
|
||||
}
|
||||
11
src/equality-map/index.ts
Normal file
11
src/equality-map/index.ts
Normal file
@@ -0,0 +1,11 @@
|
||||
import { EqualityComparisonOrComparer, MaybeAsyncEqualityComparisonOrComparer } from "../equality-comparer/types.js";
|
||||
import { CustomAsyncEqualityMap, CustomEqualityMap, NativeAsyncEqualityMap, NativeEqualityMap } from "./impl.js";
|
||||
import { AsyncEqualityMap, EqualityMap } from "./types.js";
|
||||
|
||||
export function createEqualityMap<K, V>(keyComparer?: EqualityComparisonOrComparer<K>): EqualityMap<K, V> {
|
||||
return keyComparer ? new CustomEqualityMap<K, V>(keyComparer) : new NativeEqualityMap<K, V>();
|
||||
}
|
||||
|
||||
export function createAsyncEqualityMap<K, V>(keyComparer?: MaybeAsyncEqualityComparisonOrComparer<K>): AsyncEqualityMap<K, V> {
|
||||
return keyComparer ? new CustomAsyncEqualityMap<K, V>(keyComparer) : new NativeAsyncEqualityMap<K, V>();
|
||||
}
|
||||
29
src/equality-map/types.ts
Normal file
29
src/equality-map/types.ts
Normal file
@@ -0,0 +1,29 @@
|
||||
import { MaybeAsyncIterable } from "../types.js";
|
||||
|
||||
export type EqualityMapEntry<K, V> = [key: K, value: V];
|
||||
|
||||
export interface EqualityMap<K, V> extends Iterable<EqualityMapEntry<K, V>> {
|
||||
readonly size: number;
|
||||
get(key: K): V | undefined;
|
||||
set(key: K, value: V): V | undefined;
|
||||
setAll(entries: Iterable<EqualityMapEntry<K, V>>): void;
|
||||
contains(key: K): boolean;
|
||||
remove(key: K): V | undefined;
|
||||
clear(): void;
|
||||
keys(): IterableIterator<K>;
|
||||
values(): IterableIterator<V>;
|
||||
entries(): IterableIterator<EqualityMapEntry<K, V>>;
|
||||
}
|
||||
|
||||
export interface AsyncEqualityMap<K, V> extends Iterable<EqualityMapEntry<K, V>> {
|
||||
readonly size: number;
|
||||
get(key: K): Promise<V | undefined>;
|
||||
set(key: K, value: V): Promise<V | undefined>;
|
||||
setAll(entries: MaybeAsyncIterable<EqualityMapEntry<K, V>>): Promise<void>;
|
||||
contains(key: K): Promise<boolean>;
|
||||
remove(key: K): Promise<V | undefined>;
|
||||
clear(): void;
|
||||
keys(): IterableIterator<K>;
|
||||
values(): IterableIterator<V>;
|
||||
entries(): IterableIterator<EqualityMapEntry<K, V>>;
|
||||
}
|
||||
@@ -1,17 +1,10 @@
|
||||
import { EqualityComparison, MaybeAsyncEqualityComparison } from "./equality-comparer/types.js";
|
||||
import { MaybeAsyncIterable } from "./types.js";
|
||||
import { asAsyncEqualityComparer } from "../equality-comparer/async.js";
|
||||
import { asEqualityComparer } from "../equality-comparer/sync.js";
|
||||
import { AsyncEqualityComparer, EqualityComparer, EqualityComparisonOrComparer, MaybeAsyncEqualityComparisonOrComparer } from "../equality-comparer/types.js";
|
||||
import { MaybeAsyncIterable } from "../types.js";
|
||||
import { AsyncEqualitySet, EqualitySet } from "./types.js";
|
||||
|
||||
export interface EqualitySet<T> extends Iterable<T> {
|
||||
readonly size: number;
|
||||
add(value: T): boolean;
|
||||
addAll(values: Iterable<T>): number;
|
||||
contains(value: T): boolean;
|
||||
remove(value: T): boolean;
|
||||
clear(): void;
|
||||
values(): IterableIterator<T>;
|
||||
}
|
||||
|
||||
class NativeEqualitySet<T> implements EqualitySet<T> {
|
||||
export class NativeEqualitySet<T> implements EqualitySet<T> {
|
||||
readonly #set = new Set<T>();
|
||||
|
||||
get size() {
|
||||
@@ -57,12 +50,12 @@ class NativeEqualitySet<T> implements EqualitySet<T> {
|
||||
}
|
||||
}
|
||||
|
||||
class CustomEqualitySet<T> implements EqualitySet<T> {
|
||||
export class CustomEqualitySet<T> implements EqualitySet<T> {
|
||||
readonly #list: T[] = [];
|
||||
readonly #equater: EqualityComparison<T>;
|
||||
readonly #equater: EqualityComparer<T>;
|
||||
|
||||
constructor(equater: EqualityComparison<T>) {
|
||||
this.#equater = equater;
|
||||
constructor(equater: EqualityComparisonOrComparer<T>) {
|
||||
this.#equater = asEqualityComparer(equater);
|
||||
}
|
||||
|
||||
get size() {
|
||||
@@ -93,7 +86,7 @@ class CustomEqualitySet<T> implements EqualitySet<T> {
|
||||
|
||||
contains(value: T) {
|
||||
for (const val of this.#list) {
|
||||
if (this.#equater(value, val)) {
|
||||
if (this.#equater.equals(value, val)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -105,7 +98,7 @@ class CustomEqualitySet<T> implements EqualitySet<T> {
|
||||
const length = this.#list.length;
|
||||
|
||||
for (let i = 0; i < length; i++) {
|
||||
if (this.#equater(value, this.#list[i])) {
|
||||
if (this.#equater.equals(value, this.#list[i])) {
|
||||
this.#list.splice(i, 1);
|
||||
return true;
|
||||
}
|
||||
@@ -127,21 +120,7 @@ class CustomEqualitySet<T> implements EqualitySet<T> {
|
||||
}
|
||||
}
|
||||
|
||||
export function createEqualitySet<T>(equater?: EqualityComparison<T>): EqualitySet<T> {
|
||||
return equater ? new CustomEqualitySet(equater) : new NativeEqualitySet<T>();
|
||||
}
|
||||
|
||||
export interface AsyncEqualitySet<T> extends Iterable<T> {
|
||||
readonly size: number;
|
||||
add(value: T): Promise<boolean>;
|
||||
addAll(values: MaybeAsyncIterable<T>): Promise<number>;
|
||||
contains(value: T): Promise<boolean>;
|
||||
remove(value: T): Promise<boolean>;
|
||||
clear(): void;
|
||||
values(): IterableIterator<T>;
|
||||
}
|
||||
|
||||
class NativeAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
|
||||
export class NativeAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
|
||||
readonly #set = new Set<T>();
|
||||
|
||||
get size() {
|
||||
@@ -187,12 +166,12 @@ class NativeAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
|
||||
}
|
||||
}
|
||||
|
||||
class CustomAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
|
||||
export class CustomAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
|
||||
readonly #list: T[] = [];
|
||||
readonly #equater: MaybeAsyncEqualityComparison<T>;
|
||||
readonly #equater: AsyncEqualityComparer<T>;
|
||||
|
||||
constructor(equater: MaybeAsyncEqualityComparison<T>) {
|
||||
this.#equater = equater;
|
||||
constructor(equater: MaybeAsyncEqualityComparisonOrComparer<T>) {
|
||||
this.#equater = asAsyncEqualityComparer(equater);
|
||||
}
|
||||
|
||||
get size() {
|
||||
@@ -223,7 +202,7 @@ class CustomAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
|
||||
|
||||
async contains(value: T) {
|
||||
for (const val of this.#list) {
|
||||
if (await this.#equater(value, val)) {
|
||||
if (await this.#equater.equals(value, val)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -235,7 +214,7 @@ class CustomAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
|
||||
const length = this.#list.length;
|
||||
|
||||
for (let i = 0; i < length; i++) {
|
||||
if (await this.#equater(value, this.#list[i])) {
|
||||
if (await this.#equater.equals(value, this.#list[i])) {
|
||||
this.#list.splice(i, 1);
|
||||
return true;
|
||||
}
|
||||
@@ -256,7 +235,3 @@ class CustomAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
|
||||
return this.#list[Symbol.iterator]();
|
||||
}
|
||||
}
|
||||
|
||||
export function createAsyncEqualitySet<T>(equater?: MaybeAsyncEqualityComparison<T>): AsyncEqualitySet<T> {
|
||||
return equater ? new CustomAsyncEqualitySet(equater) : new NativeAsyncEqualitySet<T>();
|
||||
}
|
||||
11
src/equality-set/index.ts
Normal file
11
src/equality-set/index.ts
Normal file
@@ -0,0 +1,11 @@
|
||||
import { EqualityComparisonOrComparer, MaybeAsyncEqualityComparisonOrComparer } from "../equality-comparer/types.js";
|
||||
import { CustomAsyncEqualitySet, CustomEqualitySet, NativeAsyncEqualitySet, NativeEqualitySet } from "./impl.js";
|
||||
import { AsyncEqualitySet, EqualitySet } from "./types.js";
|
||||
|
||||
export function createEqualitySet<T>(equater?: EqualityComparisonOrComparer<T>): EqualitySet<T> {
|
||||
return equater ? new CustomEqualitySet(equater) : new NativeEqualitySet<T>();
|
||||
}
|
||||
|
||||
export function createAsyncEqualitySet<T>(equater?: MaybeAsyncEqualityComparisonOrComparer<T>): AsyncEqualitySet<T> {
|
||||
return equater ? new CustomAsyncEqualitySet(equater) : new NativeAsyncEqualitySet<T>();
|
||||
}
|
||||
21
src/equality-set/types.ts
Normal file
21
src/equality-set/types.ts
Normal file
@@ -0,0 +1,21 @@
|
||||
import { MaybeAsyncIterable } from "../types.js";
|
||||
|
||||
export interface EqualitySet<T> extends Iterable<T> {
|
||||
readonly size: number;
|
||||
add(value: T): boolean;
|
||||
addAll(values: Iterable<T>): number;
|
||||
contains(value: T): boolean;
|
||||
remove(value: T): boolean;
|
||||
clear(): void;
|
||||
values(): IterableIterator<T>;
|
||||
}
|
||||
|
||||
export interface AsyncEqualitySet<T> extends Iterable<T> {
|
||||
readonly size: number;
|
||||
add(value: T): Promise<boolean>;
|
||||
addAll(values: MaybeAsyncIterable<T>): Promise<number>;
|
||||
contains(value: T): Promise<boolean>;
|
||||
remove(value: T): Promise<boolean>;
|
||||
clear(): void;
|
||||
values(): IterableIterator<T>;
|
||||
}
|
||||
@@ -15,5 +15,12 @@ export * as Comparers from "./comparer/sync.js";
|
||||
export { BaseAsyncComparer } from "./comparer/async.js";
|
||||
export * as AsyncComparers from "./comparer/async.js";
|
||||
export * from "./comparer/types.js";
|
||||
export * as EqualityComparers from "./equality-comparer/index.js";
|
||||
export { BaseEqualityComparer } from "./equality-comparer/sync.js";
|
||||
export * as EqualityComparers from "./equality-comparer/sync.js";
|
||||
export { BaseAsyncEqualityComparer } from "./equality-comparer/async.js";
|
||||
export * as AsyncEqualityComparers from "./equality-comparer/async.js";
|
||||
export * from "./equality-comparer/types.js";
|
||||
export * as EqualityMaps from "./equality-map/index.js";
|
||||
export * from "./equality-map/types.js";
|
||||
export * as EqualitySets from "./equality-set/index.js";
|
||||
export * from "./equality-set/types.js";
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
import { create as createBitArray } from "../bitarray/index.js";
|
||||
import { BitArray } from "../bitarray/types.js";
|
||||
import { BitArray } from "../bitarray/index.js";
|
||||
import { asArray } from "../utils.js";
|
||||
import { AsyncRandomOptions, ElementPredicate, ElementWeight, RandomGenerator, RandomOptions } from "./types.js";
|
||||
import { AsyncRandomOptions, ElementPredicate, ElementWeight, RandomElement, RandomGenerator, RandomOptions } from "./types.js";
|
||||
|
||||
export const alwaysTrue: ElementPredicate = () => true;
|
||||
export const weightOfOne: ElementWeight = () => 1.0;
|
||||
@@ -46,9 +45,10 @@ function withDefaultOptions<T>(options: RandomOptions<T> | AsyncRandomOptions<T>
|
||||
};
|
||||
}
|
||||
|
||||
function _getRandomElement<T>(sequence: Iterable<T>, options: Required<RandomOptions<T>>) {
|
||||
function _getRandomElement<T>(sequence: Iterable<T>, options: Required<RandomOptions<T>>): RandomElement<T> {
|
||||
const { predicate, weight, random } = options;
|
||||
|
||||
let found = false;
|
||||
let result: T | undefined = undefined;
|
||||
let resultIndex = -1;
|
||||
let index = 0;
|
||||
@@ -67,22 +67,24 @@ function _getRandomElement<T>(sequence: Iterable<T>, options: Required<RandomOpt
|
||||
weightAcc += w;
|
||||
|
||||
if (random() * weightAcc < w) {
|
||||
found = true;
|
||||
result = element;
|
||||
resultIndex = currentIndex;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return { element: result, index: resultIndex };
|
||||
return { found, element: result, index: resultIndex } as RandomElement<T>;
|
||||
}
|
||||
|
||||
export function getRandomElement<T>(sequence: Iterable<T>, options?: RandomOptions<T>) {
|
||||
return _getRandomElement(sequence, withDefaultOptions(options));
|
||||
}
|
||||
|
||||
async function _getRandomElementAsync<T>(sequence: AsyncIterable<T>, options: Required<AsyncRandomOptions<T>>) {
|
||||
async function _getRandomElementAsync<T>(sequence: AsyncIterable<T>, options: Required<AsyncRandomOptions<T>>): Promise<RandomElement<T>> {
|
||||
const { predicate, weight, random } = options;
|
||||
|
||||
let found = false;
|
||||
let result: T | undefined = undefined;
|
||||
let resultIndex = -1;
|
||||
let index = 0;
|
||||
@@ -101,13 +103,14 @@ async function _getRandomElementAsync<T>(sequence: AsyncIterable<T>, options: Re
|
||||
weightAcc += w;
|
||||
|
||||
if (random() * weightAcc < w) {
|
||||
found = true;
|
||||
result = element;
|
||||
resultIndex = currentIndex;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return { element: result, index: resultIndex };
|
||||
return { found, element: result, index: resultIndex } as RandomElement<T>;
|
||||
}
|
||||
|
||||
export async function getRandomElementAsync<T>(sequence: AsyncIterable<T>, options?: AsyncRandomOptions<T>) {
|
||||
@@ -121,7 +124,7 @@ export class RandomPicker<T> {
|
||||
|
||||
public constructor(elements: Iterable<T>, length: number, options?: RandomOptions<T>) {
|
||||
this.#elements = elements;
|
||||
this.#flags = createBitArray(length);
|
||||
this.#flags = BitArray.create(length);
|
||||
this.#options = withDefaultOptions(mergeOptions({ predicate: i => this.#flags.get(i) }, options));
|
||||
|
||||
this.reset();
|
||||
|
||||
@@ -4,7 +4,7 @@ export type ElementPredicate<T = any> = (index: number, obj: T) => boolean;
|
||||
export type ElementWeight<T = any> = (index: number, obj: T) => number;
|
||||
export type RandomGenerator = () => number;
|
||||
|
||||
export interface RandomOptions<T = any> {
|
||||
export type RandomOptions<T = any> = {
|
||||
predicate?: ElementPredicate<T>;
|
||||
weight?: ElementWeight<T>;
|
||||
random?: RandomGenerator;
|
||||
@@ -13,8 +13,20 @@ export interface RandomOptions<T = any> {
|
||||
export type MaybeAsyncElementPredicate<T = any> = MaybeAsyncFunction<ElementPredicate<T>>;
|
||||
export type MaybeAsyncElementWeight<T = any> = MaybeAsyncFunction<ElementWeight<T>>;
|
||||
|
||||
export interface AsyncRandomOptions<T = any> {
|
||||
export type AsyncRandomOptions<T = any> = {
|
||||
predicate?: MaybeAsyncElementPredicate<T>;
|
||||
weight?: MaybeAsyncElementWeight<T>;
|
||||
random?: RandomGenerator;
|
||||
};
|
||||
|
||||
type RandomElementFound<T> = {
|
||||
found: true;
|
||||
element: T;
|
||||
index: number;
|
||||
};
|
||||
type RandomElementNotFound = {
|
||||
found: false;
|
||||
element: undefined;
|
||||
index: -1;
|
||||
};
|
||||
export type RandomElement<T> = RandomElementFound<T> | RandomElementNotFound;
|
||||
|
||||
270
src/sync/impl.ts
270
src/sync/impl.ts
@@ -1,16 +1,17 @@
|
||||
import { BaseAsyncSequence } from "../async/impl.js";
|
||||
import { AsyncSequence } from "../async/types.js";
|
||||
import { Collector } from "../collector/types.js";
|
||||
import { asComparer, combineNullableComparers, createComparerUsing, defaultComparer } from "../comparer/sync.js";
|
||||
import { asComparer, combineComparers, createComparerUsing, defaultComparer } from "../comparer/sync.js";
|
||||
import { ComparisonOrComparer, Comparer } from "../comparer/types.js";
|
||||
import { strictEquals, identity } from "../equality-comparer/index.js";
|
||||
import { EqualityComparison } from "../equality-comparer/types.js";
|
||||
import { createEqualityMap } from "../equality-map.js";
|
||||
import { createEqualitySet } from "../equality-set.js";
|
||||
import { asEqualityComparer, defaultEqualityComparer } from "../equality-comparer/sync.js";
|
||||
import { EqualityComparer, EqualityComparisonOrComparer } from "../equality-comparer/types.js";
|
||||
import { createEqualityMap } from "../equality-map/index.js";
|
||||
import { createEqualitySet } from "../equality-set/index.js";
|
||||
import { createQueue } from "../queue.js";
|
||||
import { getRandomElement } from "../random/index.js";
|
||||
import { RandomOptions } from "../random/types.js";
|
||||
import { AnyPredicate, Converter, TypePredicate, BiConverter, Accumulator, Action } from "../types.js";
|
||||
import { FindElementResult, identity } from "../utils.js";
|
||||
import { array, empty, wrap } from "./index.js";
|
||||
import { Sequence, GroupedSequence, OrderedSequence, SequencePipeline } from "./types.js";
|
||||
|
||||
@@ -49,25 +50,23 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
|
||||
return new WhereSequence<TElement, any>(this, predicate);
|
||||
}
|
||||
|
||||
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyComparer?: EqualityComparison<TKey>): Sequence<GroupedSequence<TKey, TResult>> {
|
||||
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<GroupedSequence<TKey, TResult>> {
|
||||
return new GroupBySequence<TElement, TKey, TResult>(this, keySelector, elementSelector, keyComparer);
|
||||
}
|
||||
|
||||
join<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, TOther, TResult>, keyComparer?: EqualityComparison<TKey>): Sequence<TResult> {
|
||||
join<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, TOther, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<TResult> {
|
||||
return new JoinSequence<TElement, TOther, TKey, TResult>(this, wrap(sequence), firstKeySelector, secondKeySelector, resultSelector, keyComparer);
|
||||
}
|
||||
|
||||
groupJoin<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, Iterable<TOther>, TResult>, keyComparer?: EqualityComparison<TKey>): Sequence<TResult> {
|
||||
groupJoin<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, Iterable<TOther>, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<TResult> {
|
||||
return new GroupJoinSequence<TElement, TOther, TKey, TResult>(this, wrap(sequence), firstKeySelector, secondKeySelector, resultSelector, keyComparer);
|
||||
}
|
||||
|
||||
contains(obj: TElement, equater?: EqualityComparison<TElement>) {
|
||||
if (!equater) {
|
||||
equater = strictEquals;
|
||||
}
|
||||
contains(obj: TElement, equater?: EqualityComparisonOrComparer<TElement>) {
|
||||
equater = equater ? asEqualityComparer(equater) : defaultEqualityComparer;
|
||||
|
||||
for (const element of this) {
|
||||
if (equater(element, obj)) {
|
||||
if (equater.equals(element, obj)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -75,7 +74,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
|
||||
return false;
|
||||
}
|
||||
|
||||
sequenceEquals(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>) {
|
||||
sequenceEquals(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>) {
|
||||
if (this === sequence) {
|
||||
return true;
|
||||
}
|
||||
@@ -89,9 +88,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!equater) {
|
||||
equater = strictEquals;
|
||||
}
|
||||
equater = equater ? asEqualityComparer(equater) : defaultEqualityComparer;
|
||||
|
||||
const thisIterator = this.iterator();
|
||||
const thatIterator = other.iterator();
|
||||
@@ -108,7 +105,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!equater(thisNext.value, thatNext.value)) {
|
||||
if (!equater.equals(thisNext.value, thatNext.value)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -122,7 +119,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
|
||||
return new PrependSequence<TElement>(this, obj);
|
||||
}
|
||||
|
||||
remove(obj: TElement, all?: boolean, equater?: EqualityComparison<TElement>): Sequence<TElement> {
|
||||
remove(obj: TElement, all?: boolean, equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement> {
|
||||
return new RemoveSequence<TElement>(this, obj, all, equater);
|
||||
}
|
||||
|
||||
@@ -181,7 +178,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
|
||||
return n >= 0 ? n : Infinity;
|
||||
}
|
||||
|
||||
#tryGetFirst(predicate?: AnyPredicate<TElement>): { found: boolean, element?: TElement | undefined; } {
|
||||
#tryGetFirst(predicate?: AnyPredicate<TElement>): FindElementResult<TElement> {
|
||||
if (predicate) {
|
||||
for (const element of this) {
|
||||
if (predicate(element)) {
|
||||
@@ -211,7 +208,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
|
||||
const result = this.#tryGetFirst(predicate);
|
||||
|
||||
if (result.found) {
|
||||
return result.element!;
|
||||
return result.element;
|
||||
}
|
||||
|
||||
throw new Error("No element was found.");
|
||||
@@ -223,35 +220,37 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
|
||||
return result.found ? result.element : def;
|
||||
}
|
||||
|
||||
#tryGetLast(predicate?: AnyPredicate<TElement>): { found: boolean, element?: TElement; } {
|
||||
let found = false;
|
||||
let result: TElement | undefined = undefined;
|
||||
#tryGetLast(predicate?: AnyPredicate<TElement>): FindElementResult<TElement> {
|
||||
let result: FindElementResult<TElement> = {
|
||||
found: false
|
||||
};
|
||||
|
||||
if (predicate) {
|
||||
for (const element of this) {
|
||||
if (predicate(element)) {
|
||||
found = true;
|
||||
result = element;
|
||||
result = {
|
||||
found: true,
|
||||
element
|
||||
};
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (const element of this) {
|
||||
found = true;
|
||||
result = element;
|
||||
result = {
|
||||
found: true,
|
||||
element
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
found,
|
||||
element: result
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
last(predicate?: AnyPredicate<TElement>) {
|
||||
const result = this.#tryGetLast(predicate);
|
||||
|
||||
if (result.found) {
|
||||
return result.element!;
|
||||
return result.element;
|
||||
}
|
||||
|
||||
throw new Error("No element was found.");
|
||||
@@ -263,9 +262,9 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
|
||||
return result.found ? result.element : def;
|
||||
}
|
||||
|
||||
#tryGetSingle(predicate?: AnyPredicate<TElement>): { found: boolean, element?: TElement, reason?: number; } {
|
||||
#tryGetSingle(predicate?: AnyPredicate<TElement>): FindElementResult<TElement> {
|
||||
if (predicate) {
|
||||
let result: { found: boolean; element: TElement; } | undefined = undefined;
|
||||
let result: FindElementResult<TElement> | undefined = undefined;
|
||||
|
||||
for (const element of this) {
|
||||
if (predicate(element)) {
|
||||
@@ -287,7 +286,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
|
||||
let next = iterator.next();
|
||||
|
||||
if (!next.done) {
|
||||
const result = {
|
||||
const result: FindElementResult<TElement> = {
|
||||
found: true,
|
||||
element: next.value
|
||||
};
|
||||
@@ -315,11 +314,11 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
|
||||
const result = this.#tryGetSingle(predicate);
|
||||
|
||||
if (result.found) {
|
||||
return result.element!;
|
||||
return result.element;
|
||||
}
|
||||
|
||||
let reason: string;
|
||||
switch (result.reason!) {
|
||||
switch (result.reason) {
|
||||
case 1:
|
||||
reason = "No element was found.";
|
||||
break;
|
||||
@@ -338,7 +337,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
|
||||
return result.found ? result.element : def;
|
||||
}
|
||||
|
||||
#tryElementAt(index: number) {
|
||||
#tryElementAt(index: number): FindElementResult<TElement> {
|
||||
let i = index;
|
||||
|
||||
for (const element of this) {
|
||||
@@ -346,7 +345,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
|
||||
return {
|
||||
found: true,
|
||||
element
|
||||
} as const;
|
||||
};
|
||||
}
|
||||
|
||||
i--;
|
||||
@@ -354,7 +353,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
|
||||
|
||||
return {
|
||||
found: false
|
||||
} as const;
|
||||
};
|
||||
}
|
||||
|
||||
elementAt(index: number) {
|
||||
@@ -524,27 +523,27 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
|
||||
return new OrderBySequence<TElement, TBy>(this, true, selector, comparer);
|
||||
}
|
||||
|
||||
partition(equater?: EqualityComparison<TElement>): Sequence<Sequence<TElement>> {
|
||||
partition(equater?: EqualityComparisonOrComparer<TElement>): Sequence<Sequence<TElement>> {
|
||||
return new PartitionSequence<TElement>(this, equater);
|
||||
}
|
||||
|
||||
partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<Sequence<TElement>> {
|
||||
partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<Sequence<TElement>> {
|
||||
return new PartitionBySequence<TElement, TBy>(this, selector, equater);
|
||||
}
|
||||
|
||||
distinct(equater?: EqualityComparison<TElement>): Sequence<TElement> {
|
||||
distinct(equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement> {
|
||||
return new DistinctSequence<TElement>(this, equater);
|
||||
}
|
||||
|
||||
distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<TElement> {
|
||||
distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<TElement> {
|
||||
return new DistinctBySequence<TElement, TBy>(this, selector, equater);
|
||||
}
|
||||
|
||||
union(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>): Sequence<TElement> {
|
||||
union(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement> {
|
||||
return new UnionSequence<TElement>(this, wrap(sequence), equater);
|
||||
}
|
||||
|
||||
unionBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<TElement> {
|
||||
unionBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<TElement> {
|
||||
return new UnionBySequence<TElement, TBy>(this, wrap(sequence), selector, equater);
|
||||
}
|
||||
|
||||
@@ -674,6 +673,10 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
|
||||
return new ZippedSequence<TElement, TOther>(this, wrap(sequence));
|
||||
}
|
||||
|
||||
cartesianProduct<TOther>(sequence: Iterable<TOther>): Sequence<[TElement, TOther]> {
|
||||
return new CartesianProductSequence<TElement, TOther>(this, wrap(sequence));
|
||||
}
|
||||
|
||||
indexed(): Sequence<[number, TElement]> {
|
||||
return new IndexedSequence<TElement>(this);
|
||||
}
|
||||
@@ -830,29 +833,29 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
|
||||
return this.#sequence.where(predicate);
|
||||
}
|
||||
|
||||
groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: EqualityComparison<TKey> | undefined): Sequence<GroupedSequence<TKey, TElement>>;
|
||||
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: EqualityComparison<TKey> | undefined): Sequence<GroupedSequence<TKey, TResult>>;
|
||||
groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: EqualityComparisonOrComparer<TKey> | undefined): Sequence<GroupedSequence<TKey, TElement>>;
|
||||
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey> | undefined): Sequence<GroupedSequence<TKey, TResult>>;
|
||||
groupBy(keySelector: any, elementSelector?: any, keyComparer?: any) {
|
||||
return this.#sequence.groupBy(keySelector, elementSelector, keyComparer);
|
||||
}
|
||||
|
||||
join<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparison<TKey> | undefined): Sequence<[TElement, TOther]>;
|
||||
join<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: EqualityComparison<TKey> | undefined): Sequence<TResult>;
|
||||
join<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparisonOrComparer<TKey> | undefined): Sequence<[TElement, TOther]>;
|
||||
join<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey> | undefined): Sequence<TResult>;
|
||||
join(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
|
||||
return this.#sequence.join(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
|
||||
}
|
||||
|
||||
groupJoin<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparison<TKey> | undefined): Sequence<GroupedSequence<TElement, TOther>>;
|
||||
groupJoin<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Iterable<TOther>, TResult>, keyComparer?: EqualityComparison<TKey> | undefined): Sequence<TResult>;
|
||||
groupJoin<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparisonOrComparer<TKey> | undefined): Sequence<GroupedSequence<TElement, TOther>>;
|
||||
groupJoin<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Iterable<TOther>, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey> | undefined): Sequence<TResult>;
|
||||
groupJoin(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
|
||||
return this.#sequence.groupJoin(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
|
||||
}
|
||||
|
||||
contains(obj: TElement, equater?: EqualityComparison<TElement>) {
|
||||
contains(obj: TElement, equater?: EqualityComparisonOrComparer<TElement>) {
|
||||
return this.#sequence.contains(obj, equater);
|
||||
}
|
||||
|
||||
sequenceEquals(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>) {
|
||||
sequenceEquals(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>) {
|
||||
return this.#sequence.sequenceEquals(sequence, equater);
|
||||
}
|
||||
|
||||
@@ -864,7 +867,7 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
|
||||
return this.#sequence.prepend(obj);
|
||||
}
|
||||
|
||||
remove(obj: TElement, all?: boolean, equater?: EqualityComparison<TElement>) {
|
||||
remove(obj: TElement, all?: boolean, equater?: EqualityComparisonOrComparer<TElement>) {
|
||||
return this.#sequence.remove(obj, all, equater);
|
||||
}
|
||||
|
||||
@@ -948,43 +951,43 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
|
||||
return this.#sequence.orderByDescending(selector, comparer);
|
||||
}
|
||||
|
||||
partition(equater?: EqualityComparison<TElement> | undefined): Sequence<Sequence<TElement>> {
|
||||
partition(equater?: EqualityComparisonOrComparer<TElement> | undefined): Sequence<Sequence<TElement>> {
|
||||
return this.#sequence.partition(equater);
|
||||
}
|
||||
|
||||
partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy> | undefined): Sequence<Sequence<TElement>> {
|
||||
partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy> | undefined): Sequence<Sequence<TElement>> {
|
||||
return this.#sequence.partitionBy(selector, equater);
|
||||
}
|
||||
|
||||
distinct(equater?: EqualityComparison<TElement>) {
|
||||
distinct(equater?: EqualityComparisonOrComparer<TElement>) {
|
||||
return this.#sequence.distinct(equater);
|
||||
}
|
||||
|
||||
distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>) {
|
||||
distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>) {
|
||||
return this.#sequence.distinctBy(selector, equater);
|
||||
}
|
||||
|
||||
union(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>) {
|
||||
union(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>) {
|
||||
return this.#sequence.union(sequence, equater);
|
||||
}
|
||||
|
||||
unionBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>) {
|
||||
unionBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>) {
|
||||
return this.#sequence.unionBy(sequence, selector, equater);
|
||||
}
|
||||
|
||||
except(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>) {
|
||||
except(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>) {
|
||||
return this.#sequence.except(sequence, equater);
|
||||
}
|
||||
|
||||
exceptBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>) {
|
||||
exceptBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>) {
|
||||
return this.#sequence.exceptBy(sequence, selector, equater);
|
||||
}
|
||||
|
||||
intersect(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>) {
|
||||
intersect(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>) {
|
||||
return this.#sequence.intersect(sequence, equater);
|
||||
}
|
||||
|
||||
intersectBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>) {
|
||||
intersectBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>) {
|
||||
return this.#sequence.intersectBy(sequence, selector, equater);
|
||||
}
|
||||
|
||||
@@ -1040,6 +1043,10 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
|
||||
return this.#sequence.zip(sequence);
|
||||
}
|
||||
|
||||
cartesianProduct<TOther>(sequence: Iterable<TOther>) {
|
||||
return this.#sequence.cartesianProduct(sequence);
|
||||
}
|
||||
|
||||
indexed() {
|
||||
return this.#sequence.indexed();
|
||||
}
|
||||
@@ -1164,11 +1171,7 @@ export abstract class BaseOrderedSequence<TElement> extends BaseSequence<TElemen
|
||||
}
|
||||
|
||||
override *iterator() {
|
||||
const arr: TElement[] = [];
|
||||
|
||||
for (const obj of this.#sequence) {
|
||||
arr.push(obj);
|
||||
}
|
||||
const arr = Array.from(this.#sequence);
|
||||
|
||||
if (this.#sorter) {
|
||||
arr.sort((this.#descending ? this.#sorter.reverse() : this.#sorter).comparison());
|
||||
@@ -1371,9 +1374,10 @@ export class WrappedArray<T> extends BaseSequence<T> {
|
||||
return this.#array.length;
|
||||
}
|
||||
|
||||
override contains(obj: T, equater?: EqualityComparison<T>): boolean {
|
||||
override contains(obj: T, equater?: EqualityComparisonOrComparer<T>): boolean {
|
||||
if (equater) {
|
||||
return this.#array.some(x => equater(x, obj));
|
||||
const equalityComparer = asEqualityComparer(equater);
|
||||
return this.#array.some(x => equalityComparer.equals(x, obj));
|
||||
}
|
||||
|
||||
return this.#array.includes(obj);
|
||||
@@ -1467,7 +1471,7 @@ export class WrappedSet<T> extends BaseSequence<T> {
|
||||
return this.#set.size;
|
||||
}
|
||||
|
||||
override contains(obj: T, equater?: EqualityComparison<T>) {
|
||||
override contains(obj: T, equater?: EqualityComparisonOrComparer<T>) {
|
||||
if (equater) {
|
||||
return super.contains(obj, equater);
|
||||
}
|
||||
@@ -1497,7 +1501,7 @@ export class WrappedMap<K, V> extends BaseSequence<[K, V]> {
|
||||
return this.#map.size;
|
||||
}
|
||||
|
||||
override contains(obj: [K, V], equater?: EqualityComparison<[K, V]>) {
|
||||
override contains(obj: [K, V], equater?: EqualityComparisonOrComparer<[K, V]>) {
|
||||
if (equater) {
|
||||
return super.contains(obj, equater);
|
||||
}
|
||||
@@ -1606,9 +1610,9 @@ export class ConcatSequence<T> extends BaseSequence<T> {
|
||||
|
||||
class DistinctSequence<T> extends BaseSequence<T> {
|
||||
readonly #sequence: Sequence<T>;
|
||||
readonly #equater: EqualityComparison<T> | undefined;
|
||||
readonly #equater: EqualityComparisonOrComparer<T> | undefined;
|
||||
|
||||
constructor(sequence: Sequence<T>, equater?: EqualityComparison<T>) {
|
||||
constructor(sequence: Sequence<T>, equater?: EqualityComparisonOrComparer<T>) {
|
||||
super();
|
||||
|
||||
this.#sequence = sequence;
|
||||
@@ -1633,9 +1637,9 @@ class DistinctSequence<T> extends BaseSequence<T> {
|
||||
class DistinctBySequence<T, U> extends BaseSequence<T> {
|
||||
readonly #sequence: Sequence<T>;
|
||||
readonly #converter: Converter<T, U>;
|
||||
readonly #equater: EqualityComparison<U> | undefined;
|
||||
readonly #equater: EqualityComparisonOrComparer<U> | undefined;
|
||||
|
||||
constructor(sequence: Sequence<T>, converter: Converter<T, U>, equater?: EqualityComparison<U>) {
|
||||
constructor(sequence: Sequence<T>, converter: Converter<T, U>, equater?: EqualityComparisonOrComparer<U>) {
|
||||
super();
|
||||
|
||||
this.#sequence = sequence;
|
||||
@@ -1970,13 +1974,13 @@ class OrderBySequence<T, U> extends BaseOrderedSequence<T> {
|
||||
|
||||
class ThenOrderSequence<T> extends BaseOrderedSequence<T> {
|
||||
constructor(sequence: OrderedSequence<T>, descending: boolean, sorter?: ComparisonOrComparer<T>) {
|
||||
super(sequence, combineNullableComparers([sequence.comparer, sorter]), descending);
|
||||
super(sequence, combineComparers([sequence.comparer, sorter]), descending);
|
||||
}
|
||||
}
|
||||
|
||||
class ThenOrderBySequence<T, U> extends BaseOrderedSequence<T> {
|
||||
constructor(sequence: OrderedSequence<T>, descending: boolean, selector: Converter<T, U>, sorter?: ComparisonOrComparer<U>) {
|
||||
super(sequence, combineNullableComparers([sequence.comparer, createComparerUsing(selector, sorter)]), descending);
|
||||
super(sequence, combineComparers([sequence.comparer, createComparerUsing(selector, sorter)]), descending);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2098,12 +2102,52 @@ export class ZippedSequence<T, U> extends BaseSequence<[T, U]> {
|
||||
}
|
||||
}
|
||||
|
||||
export class CartesianProductSequence<T, U> extends BaseSequence<[T, U]> {
|
||||
readonly #first: Sequence<T>;
|
||||
readonly #second: Sequence<U>;
|
||||
|
||||
constructor(first: Sequence<T>, second: Sequence<U>) {
|
||||
super();
|
||||
|
||||
this.#first = first;
|
||||
this.#second = second;
|
||||
}
|
||||
|
||||
override nonEnumeratedCount() {
|
||||
const n1 = this.#first.nonEnumeratedCount();
|
||||
|
||||
if (n1 < 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
const n2 = this.#second.nonEnumeratedCount();
|
||||
|
||||
if (n2 < 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
return n1 * n2;
|
||||
}
|
||||
|
||||
override maxCount() {
|
||||
return this.#first.maxCount() * this.#second.maxCount();
|
||||
}
|
||||
|
||||
override *iterator() {
|
||||
for (const firstObj of this.#first) {
|
||||
for (const secondObj of this.#second) {
|
||||
yield [firstObj, secondObj] as [T, U];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class UnionSequence<T> extends BaseSequence<T> {
|
||||
readonly #first: Sequence<T>;
|
||||
readonly #second: Sequence<T>;
|
||||
readonly #equater: EqualityComparison<T> | undefined;
|
||||
readonly #equater: EqualityComparisonOrComparer<T> | undefined;
|
||||
|
||||
constructor(first: Sequence<T>, second: Sequence<T>, equater?: EqualityComparison<T>) {
|
||||
constructor(first: Sequence<T>, second: Sequence<T>, equater?: EqualityComparisonOrComparer<T>) {
|
||||
super();
|
||||
|
||||
this.#first = first;
|
||||
@@ -2135,9 +2179,9 @@ class UnionBySequence<T, U> extends BaseSequence<T> {
|
||||
readonly #first: Sequence<T>;
|
||||
readonly #second: Sequence<T>;
|
||||
readonly #selector: Converter<T, U>;
|
||||
readonly #equater: EqualityComparison<U> | undefined;
|
||||
readonly #equater: EqualityComparisonOrComparer<U> | undefined;
|
||||
|
||||
constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: EqualityComparison<U>) {
|
||||
constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: EqualityComparisonOrComparer<U>) {
|
||||
super();
|
||||
|
||||
this.#first = first;
|
||||
@@ -2169,9 +2213,9 @@ class UnionBySequence<T, U> extends BaseSequence<T> {
|
||||
class ExceptSequence<T> extends BaseSequence<T> {
|
||||
readonly #first: Sequence<T>;
|
||||
readonly #second: Sequence<T>;
|
||||
readonly #equater: EqualityComparison<T> | undefined;
|
||||
readonly #equater: EqualityComparisonOrComparer<T> | undefined;
|
||||
|
||||
constructor(first: Sequence<T>, second: Sequence<T>, equater?: EqualityComparison<T>) {
|
||||
constructor(first: Sequence<T>, second: Sequence<T>, equater?: EqualityComparisonOrComparer<T>) {
|
||||
super();
|
||||
|
||||
this.#first = first;
|
||||
@@ -2202,9 +2246,9 @@ class ExceptBySequence<T, U> extends BaseSequence<T> {
|
||||
readonly #first: Sequence<T>;
|
||||
readonly #second: Sequence<T>;
|
||||
readonly #selector: Converter<T, U>;
|
||||
readonly #equater: EqualityComparison<U> | undefined;
|
||||
readonly #equater: EqualityComparisonOrComparer<U> | undefined;
|
||||
|
||||
constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: EqualityComparison<U>) {
|
||||
constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: EqualityComparisonOrComparer<U>) {
|
||||
super();
|
||||
|
||||
this.#first = first;
|
||||
@@ -2235,9 +2279,9 @@ class ExceptBySequence<T, U> extends BaseSequence<T> {
|
||||
class IntersectSequence<T> extends BaseSequence<T> {
|
||||
readonly #first: Sequence<T>;
|
||||
readonly #second: Sequence<T>;
|
||||
readonly #equater: EqualityComparison<T> | undefined;
|
||||
readonly #equater: EqualityComparisonOrComparer<T> | undefined;
|
||||
|
||||
constructor(first: Sequence<T>, second: Sequence<T>, equater?: EqualityComparison<T>) {
|
||||
constructor(first: Sequence<T>, second: Sequence<T>, equater?: EqualityComparisonOrComparer<T>) {
|
||||
super();
|
||||
|
||||
this.#first = first;
|
||||
@@ -2266,9 +2310,9 @@ class IntersectBySequence<T, U> extends BaseSequence<T> {
|
||||
readonly #first: Sequence<T>;
|
||||
readonly #second: Sequence<T>;
|
||||
readonly #selector: Converter<T, U>;
|
||||
readonly #equater: EqualityComparison<U> | undefined;
|
||||
readonly #equater: EqualityComparisonOrComparer<U> | undefined;
|
||||
|
||||
constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: EqualityComparison<U>) {
|
||||
constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: EqualityComparisonOrComparer<U>) {
|
||||
super();
|
||||
|
||||
this.#first = first;
|
||||
@@ -2330,9 +2374,9 @@ class GroupBySequence<TElement, TKey, TResult> extends BaseSequence<GroupedSeque
|
||||
readonly #sequence: Sequence<TElement>;
|
||||
readonly #keySelector: Converter<TElement, TKey>;
|
||||
readonly #elementSelector: Converter<TElement, TResult>;
|
||||
readonly #keyEquater: EqualityComparison<TKey> | undefined;
|
||||
readonly #keyEquater: EqualityComparisonOrComparer<TKey> | undefined;
|
||||
|
||||
constructor(sequence: Sequence<TElement>, keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyEquater?: EqualityComparison<TKey>) {
|
||||
constructor(sequence: Sequence<TElement>, keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyEquater?: EqualityComparisonOrComparer<TKey>) {
|
||||
super();
|
||||
|
||||
this.#sequence = sequence;
|
||||
@@ -2449,9 +2493,9 @@ class JoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TResult>
|
||||
readonly #firstKeySelector: Converter<TOuter, TKey>;
|
||||
readonly #secondKeySelector: Converter<TInner, TKey>;
|
||||
readonly #resultSelector: BiConverter<TOuter, TInner, TResult>;
|
||||
readonly #keyEquater: EqualityComparison<TKey>;
|
||||
readonly #keyEquater: EqualityComparer<TKey>;
|
||||
|
||||
constructor(first: Sequence<TOuter>, second: Sequence<TInner>, firstKeySelector: Converter<TOuter, TKey>, secondKeySelector: Converter<TInner, TKey>, resultSelector?: BiConverter<TOuter, TInner, TResult>, keyEquater?: EqualityComparison<TKey>) {
|
||||
constructor(first: Sequence<TOuter>, second: Sequence<TInner>, firstKeySelector: Converter<TOuter, TKey>, secondKeySelector: Converter<TInner, TKey>, resultSelector?: BiConverter<TOuter, TInner, TResult>, keyEquater?: EqualityComparisonOrComparer<TKey>) {
|
||||
super();
|
||||
|
||||
this.#first = first;
|
||||
@@ -2459,7 +2503,7 @@ class JoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TResult>
|
||||
this.#firstKeySelector = firstKeySelector;
|
||||
this.#secondKeySelector = secondKeySelector;
|
||||
this.#resultSelector = resultSelector ?? JoinSequence.#defaultResultSelector as BiConverter<TOuter, TInner, TResult>;
|
||||
this.#keyEquater = keyEquater ?? strictEquals;
|
||||
this.#keyEquater = keyEquater ? asEqualityComparer(keyEquater) : defaultEqualityComparer;
|
||||
}
|
||||
|
||||
static #defaultResultSelector<TOuter, TInner>(first: TOuter, second: TInner): [TOuter, TInner] {
|
||||
@@ -2477,7 +2521,7 @@ class JoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TResult>
|
||||
for (const secondObj of this.#second) {
|
||||
const secondKey = this.#secondKeySelector(secondObj);
|
||||
|
||||
if (this.#keyEquater(firstKey, secondKey)) {
|
||||
if (this.#keyEquater.equals(firstKey, secondKey)) {
|
||||
yield this.#resultSelector(firstObj, secondObj);
|
||||
}
|
||||
}
|
||||
@@ -2491,9 +2535,9 @@ class GroupJoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TRes
|
||||
readonly #firstKeySelector: Converter<TOuter, TKey>;
|
||||
readonly #secondKeySelector: Converter<TInner, TKey>;
|
||||
readonly #resultSelector: BiConverter<TOuter, Sequence<TInner>, TResult>;
|
||||
readonly #keyEquater: EqualityComparison<TKey>;
|
||||
readonly #keyEquater: EqualityComparer<TKey>;
|
||||
|
||||
constructor(first: Sequence<TOuter>, second: Sequence<TInner>, firstKeySelector: Converter<TOuter, TKey>, secondKeySelector: Converter<TInner, TKey>, resultSelector?: BiConverter<TOuter, Sequence<TInner>, TResult>, keyEquater?: EqualityComparison<TKey>) {
|
||||
constructor(first: Sequence<TOuter>, second: Sequence<TInner>, firstKeySelector: Converter<TOuter, TKey>, secondKeySelector: Converter<TInner, TKey>, resultSelector?: BiConverter<TOuter, Sequence<TInner>, TResult>, keyEquater?: EqualityComparisonOrComparer<TKey>) {
|
||||
super();
|
||||
|
||||
this.#first = first;
|
||||
@@ -2501,7 +2545,7 @@ class GroupJoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TRes
|
||||
this.#firstKeySelector = firstKeySelector;
|
||||
this.#secondKeySelector = secondKeySelector;
|
||||
this.#resultSelector = resultSelector ?? GroupJoinSequence.#defaultResultSelector as BiConverter<TOuter, Sequence<TInner>, TResult>;
|
||||
this.#keyEquater = keyEquater ?? strictEquals;
|
||||
this.#keyEquater = keyEquater ? asEqualityComparer(keyEquater) : defaultEqualityComparer;
|
||||
}
|
||||
|
||||
static #defaultResultSelector<TOuter, TInner>(first: TOuter, second: Sequence<TInner>) {
|
||||
@@ -2524,7 +2568,7 @@ class GroupJoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TRes
|
||||
for (const secondObj of this.#second) {
|
||||
const secondKey = this.#secondKeySelector(secondObj);
|
||||
|
||||
if (this.#keyEquater(firstKey, secondKey)) {
|
||||
if (this.#keyEquater.equals(firstKey, secondKey)) {
|
||||
secondObjs.push(secondObj);
|
||||
}
|
||||
}
|
||||
@@ -2538,15 +2582,15 @@ class RemoveSequence<T> extends BaseSequence<T> {
|
||||
readonly #sequence: Sequence<T>;
|
||||
readonly #obj: T;
|
||||
readonly #all: boolean;
|
||||
readonly #equater: EqualityComparison<T>;
|
||||
readonly #equater: EqualityComparer<T>;
|
||||
|
||||
constructor(sequence: Sequence<T>, obj: T, all?: boolean, equater?: EqualityComparison<T>) {
|
||||
constructor(sequence: Sequence<T>, obj: T, all?: boolean, equater?: EqualityComparisonOrComparer<T>) {
|
||||
super();
|
||||
|
||||
this.#sequence = sequence;
|
||||
this.#obj = obj;
|
||||
this.#all = all ?? false;
|
||||
this.#equater = equater ?? strictEquals;
|
||||
this.#equater = equater ? asEqualityComparer(equater) : defaultEqualityComparer;
|
||||
}
|
||||
|
||||
override maxCount() {
|
||||
@@ -2557,7 +2601,7 @@ class RemoveSequence<T> extends BaseSequence<T> {
|
||||
let gotOne = false;
|
||||
|
||||
for (const obj of this.#sequence) {
|
||||
if (this.#equater(this.#obj, obj)) {
|
||||
if (this.#equater.equals(this.#obj, obj)) {
|
||||
if (this.#all) {
|
||||
continue;
|
||||
}
|
||||
@@ -2601,13 +2645,13 @@ class CacheSequence<T> extends BaseSequence<T> {
|
||||
|
||||
class PartitionSequence<T> extends BaseSequence<Sequence<T>> {
|
||||
readonly #sequence: Sequence<T>;
|
||||
readonly #equater: EqualityComparison<T>;
|
||||
readonly #equater: EqualityComparisonOrComparer<T> | undefined;
|
||||
|
||||
constructor(sequence: Sequence<T>, equater: EqualityComparison<T> | undefined) {
|
||||
constructor(sequence: Sequence<T>, equater: EqualityComparisonOrComparer<T> | undefined) {
|
||||
super();
|
||||
|
||||
this.#sequence = sequence;
|
||||
this.#equater = equater ?? strictEquals;
|
||||
this.#equater = equater;
|
||||
}
|
||||
|
||||
override *iterator() {
|
||||
@@ -2632,14 +2676,14 @@ class PartitionSequence<T> extends BaseSequence<Sequence<T>> {
|
||||
class PartitionBySequence<TElement, TBy> extends BaseSequence<Sequence<TElement>> {
|
||||
readonly #sequence: Sequence<TElement>;
|
||||
readonly #selector: Converter<TElement, TBy>;
|
||||
readonly #equater: EqualityComparison<TBy>;
|
||||
readonly #equater: EqualityComparisonOrComparer<TBy> | undefined;
|
||||
|
||||
constructor(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater: EqualityComparison<TBy> | undefined) {
|
||||
constructor(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater: EqualityComparisonOrComparer<TBy> | undefined) {
|
||||
super();
|
||||
|
||||
this.#sequence = sequence;
|
||||
this.#selector = selector;
|
||||
this.#equater = equater ?? strictEquals;
|
||||
this.#equater = equater;
|
||||
}
|
||||
|
||||
override *iterator() {
|
||||
|
||||
@@ -9,7 +9,7 @@ export function wrap<T = any>(iterable: Iterable<T>): Sequence<T> {
|
||||
}
|
||||
|
||||
if (Array.isArray(iterable)) {
|
||||
return array(iterable);
|
||||
return array<T>(iterable);
|
||||
}
|
||||
|
||||
if (iterable instanceof Set) {
|
||||
@@ -20,7 +20,7 @@ export function wrap<T = any>(iterable: Iterable<T>): Sequence<T> {
|
||||
return map(iterable) as unknown as Sequence<T>;
|
||||
}
|
||||
|
||||
return sequence(iterable);
|
||||
return sequence<T>(iterable);
|
||||
}
|
||||
|
||||
export function sequence<T = any>(iterable: Iterable<T>): Sequence<T> {
|
||||
@@ -62,10 +62,6 @@ export function of<T>(...elements: T[]): Sequence<T> {
|
||||
}
|
||||
}
|
||||
|
||||
export function ofPropertyKeys<T extends PropertyKey>(...elements: T[]): Sequence<T> {
|
||||
return of(...elements);
|
||||
}
|
||||
|
||||
export function entries<T>(o: Record<string, T> | ArrayLike<T>): Sequence<[string, T]> {
|
||||
return array(Object.entries(o));
|
||||
}
|
||||
@@ -74,7 +70,9 @@ export function keys(o: object): Sequence<string> {
|
||||
return array(Object.keys(o));
|
||||
}
|
||||
|
||||
export function values(o: object): Sequence<any> {
|
||||
export function values(o: object): Sequence<any>;
|
||||
export function values<T>(o: Record<any, T> | ArrayLike<T>): Sequence<T>;
|
||||
export function values(o: object) {
|
||||
return array(Object.values(o));
|
||||
}
|
||||
|
||||
@@ -86,9 +84,9 @@ export function generator<T>(generator: () => Iterable<T>): Sequence<T> {
|
||||
return new GeneratorSequence(generator);
|
||||
}
|
||||
|
||||
export function range(max: number): Sequence<number>
|
||||
export function range(min: number, max: number): Sequence<number>
|
||||
export function range(min: number, max: number, step: number): Sequence<number>
|
||||
export function range(max: number): Sequence<number>;
|
||||
export function range(min: number, max: number): Sequence<number>;
|
||||
export function range(min: number, max: number, step: number): Sequence<number>;
|
||||
export function range(a: number, b?: number, c?: number): Sequence<number> {
|
||||
if (b === undefined) {
|
||||
b = a;
|
||||
@@ -102,9 +100,9 @@ export function range(a: number, b?: number, c?: number): Sequence<number> {
|
||||
return new RangeSequence(a, b, c);
|
||||
}
|
||||
|
||||
export function bigintRange(max: bigint): Sequence<bigint>
|
||||
export function bigintRange(min: bigint, max: bigint): Sequence<bigint>
|
||||
export function bigintRange(min: bigint, max: bigint, step: bigint): Sequence<bigint>
|
||||
export function bigintRange(max: bigint): Sequence<bigint>;
|
||||
export function bigintRange(min: bigint, max: bigint): Sequence<bigint>;
|
||||
export function bigintRange(min: bigint, max: bigint, step: bigint): Sequence<bigint>;
|
||||
export function bigintRange(a: bigint, b?: bigint, c?: bigint): Sequence<bigint> {
|
||||
if (b === undefined) {
|
||||
b = a;
|
||||
|
||||
@@ -1,11 +1,12 @@
|
||||
import { AsyncSequence } from "../async/types.js";
|
||||
import { Collector } from "../collector/types.js";
|
||||
import { ComparisonOrComparer, Comparer } from "../comparer/types.js";
|
||||
import { EqualityComparison } from "../equality-comparer/types.js";
|
||||
import { EqualityComparisonOrComparer } from "../equality-comparer/types.js";
|
||||
import { RandomOptions } from "../random/types.js";
|
||||
import { AnyPredicate, Converter, TypePredicate, BiConverter, Accumulator, Action } from "../types.js";
|
||||
|
||||
export type SequencePipeline<TElement, TResult> = (sequence: Sequence<TElement>) => TResult;
|
||||
export type SequenceElement<TSequence extends Sequence<any>> = TSequence extends Sequence<infer TElement> ? TElement : never;
|
||||
|
||||
export interface Sequence<TElement> extends Iterable<TElement> {
|
||||
iterator(): Iterator<TElement>;
|
||||
@@ -25,24 +26,24 @@ export interface Sequence<TElement> extends Iterable<TElement> {
|
||||
where<TFiltered extends TElement>(predicate: TypePredicate<TElement, TFiltered>): Sequence<TFiltered>;
|
||||
where(predicate: AnyPredicate<TElement>): Sequence<TElement>;
|
||||
|
||||
groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: EqualityComparison<TKey>): Sequence<GroupedSequence<TKey, TElement>>;
|
||||
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: EqualityComparison<TKey>): Sequence<GroupedSequence<TKey, TResult>>;
|
||||
groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<GroupedSequence<TKey, TElement>>;
|
||||
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<GroupedSequence<TKey, TResult>>;
|
||||
|
||||
join<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparison<TKey>): Sequence<[TElement, TOther]>;
|
||||
join<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: EqualityComparison<TKey>): Sequence<TResult>;
|
||||
join<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<[TElement, TOther]>;
|
||||
join<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<TResult>;
|
||||
|
||||
groupJoin<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparison<TKey>): Sequence<GroupedSequence<TElement, TOther>>;
|
||||
groupJoin<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Iterable<TOther>, TResult>, keyComparer?: EqualityComparison<TKey>): Sequence<TResult>;
|
||||
groupJoin<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<GroupedSequence<TElement, TOther>>;
|
||||
groupJoin<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Iterable<TOther>, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<TResult>;
|
||||
|
||||
contains(obj: TElement, equater?: EqualityComparison<TElement>): boolean;
|
||||
contains(obj: TElement, equater?: EqualityComparisonOrComparer<TElement>): boolean;
|
||||
|
||||
sequenceEquals(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>): boolean;
|
||||
sequenceEquals(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>): boolean;
|
||||
|
||||
append(obj: TElement): Sequence<TElement>;
|
||||
|
||||
prepend(obj: TElement): Sequence<TElement>;
|
||||
|
||||
remove(obj: TElement, all?: boolean, equater?: EqualityComparison<TElement>): Sequence<TElement>;
|
||||
remove(obj: TElement, all?: boolean, equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement>;
|
||||
|
||||
concat(...sequences: Iterable<TElement>[]): Sequence<TElement>;
|
||||
|
||||
@@ -77,20 +78,20 @@ export interface Sequence<TElement> extends Iterable<TElement> {
|
||||
orderDescending(comparer?: ComparisonOrComparer<TElement>): OrderedSequence<TElement>;
|
||||
orderByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>): OrderedSequence<TElement>;
|
||||
|
||||
partition(equater?: EqualityComparison<TElement>): Sequence<Sequence<TElement>>;
|
||||
partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<Sequence<TElement>>;
|
||||
partition(equater?: EqualityComparisonOrComparer<TElement>): Sequence<Sequence<TElement>>;
|
||||
partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<Sequence<TElement>>;
|
||||
|
||||
distinct(equater?: EqualityComparison<TElement>): Sequence<TElement>;
|
||||
distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<TElement>;
|
||||
distinct(equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement>;
|
||||
distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<TElement>;
|
||||
|
||||
union(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>): Sequence<TElement>;
|
||||
unionBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<TElement>;
|
||||
union(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement>;
|
||||
unionBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<TElement>;
|
||||
|
||||
except(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>): Sequence<TElement>;
|
||||
exceptBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<TElement>;
|
||||
except(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement>;
|
||||
exceptBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<TElement>;
|
||||
|
||||
intersect(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>): Sequence<TElement>;
|
||||
intersectBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<TElement>;
|
||||
intersect(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement>;
|
||||
intersectBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<TElement>;
|
||||
|
||||
all(predicate: AnyPredicate<TElement>): boolean;
|
||||
any(predicate: AnyPredicate<TElement>): boolean;
|
||||
@@ -111,6 +112,7 @@ export interface Sequence<TElement> extends Iterable<TElement> {
|
||||
forEach(action: Action<TElement>): void;
|
||||
|
||||
zip<TOther>(sequence: Iterable<TOther>): Sequence<[TElement, TOther]>;
|
||||
cartesianProduct<TOther>(sequence: Iterable<TOther>): Sequence<[TElement, TOther]>;
|
||||
|
||||
indexed(): Sequence<[number, TElement]>;
|
||||
|
||||
|
||||
14
src/utils.ts
14
src/utils.ts
@@ -12,6 +12,10 @@ export function asArray<T>(iterable: Iterable<T>) {
|
||||
return Array.isArray(iterable) ? <T[]>iterable : Array.from(iterable);
|
||||
}
|
||||
|
||||
export function identity<T>(obj: T) {
|
||||
return obj;
|
||||
}
|
||||
|
||||
class WrappedAsyncIterator<T> implements AsyncIterable<T> {
|
||||
readonly #iterator: AsyncIterator<T>;
|
||||
|
||||
@@ -49,3 +53,13 @@ const _emptyIterableIterator = new class EmptyIterableIterator implements Iterab
|
||||
export function emptyIterableIterator<T>(): IterableIterator<T> {
|
||||
return _emptyIterableIterator;
|
||||
}
|
||||
|
||||
type FindElementSuccess<T> = {
|
||||
found: true;
|
||||
element: T;
|
||||
};
|
||||
type FindElementFail = {
|
||||
found: false;
|
||||
reason?: number;
|
||||
};
|
||||
export type FindElementResult<T> = FindElementSuccess<T> | FindElementFail;
|
||||
|
||||
@@ -1,22 +1,17 @@
|
||||
{
|
||||
"compilerOptions": {
|
||||
"module": "NodeNext",
|
||||
"target": "ESNext",
|
||||
"module": "nodenext",
|
||||
"target": "esnext",
|
||||
"moduleResolution": "nodenext",
|
||||
"rootDir": "src",
|
||||
"outDir": "build",
|
||||
"outFile": "build/index.ts",
|
||||
"esModuleInterop": true,
|
||||
"lib": [
|
||||
"ESNext"
|
||||
],
|
||||
"types": ["node"],
|
||||
"alwaysStrict": true,
|
||||
"strict": true,
|
||||
"allowSyntheticDefaultImports": true,
|
||||
"allowUnreachableCode": true,
|
||||
"declaration": true,
|
||||
"declarationMap": true,
|
||||
"emitDeclarationOnly": true,
|
||||
"composite": true
|
||||
"rootDir": "./src"
|
||||
},
|
||||
"include": [
|
||||
"src"
|
||||
"./src"
|
||||
]
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user