@slimlib/refine-partition 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Konstantin Shutkin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,32 @@
+# Refine Partition
+
+Simple refine partition implementation
+
+https://en.wikipedia.org/wiki/Partition_refinement
+
+> To perform a refinement operation, the algorithm loops through the elements of the given set X. For each such element x, it finds the set Si that contains x, and checks whether a second set for Si ∩ X has already been started. If not, it creates the second set and adds Si to a list L of the sets that are split by the operation. Then, regardless of whether a new set was formed, the algorithm removes x from Si and adds it to Si ∩ X. In the representation in which all elements are stored in a single array, moving x from one set to another may be performed by swapping x with the final element of Si and then decrementing the end index of Si and the start index of the new set. Finally, after all elements of X have been processed in this way, the algorithm loops through L, separating each current set Si from the second set that has been split from it, and reports both of these sets as being newly formed by the refinement operation.
+
+## API
+
+### `<T>() => (newPartitionCandidate?: Iterable<T>) => Iterable<Iterable<T>>`
+
+Create refiner funtion.
+
+Pass to it new candidates for refinement.
+
+Returns refined partition.
+
+### Example
+
+```typescript
+import refiner from '../src';
+
+const refineNext = refiner();
+refineNext(['a', 'b', 'c']);
+refineNext(['b', 'c', 'e']);
+console.log(refineNext()); // Iterable of Iterables: ((a), (b, c), (e))
+```
+
+# License
+
+[MIT](./LICENSE)

package/dist/index.cjs

@@ -0,0 +1,40 @@
+'use strict';
+
+function index () {
+    const processed = new Set();
+    return (newPartitionCandidate) => {
+        if (newPartitionCandidate) {
+            const intersections = new Map();
+            for (const element of newPartitionCandidate) {
+                for (const partitionItem of processed) {
+                    if (partitionItem.has(element)) {
+                        let intersection = intersections.get(partitionItem);
+                        if (intersection === undefined) {
+                            intersection = new Set();
+                            intersections.set(partitionItem, intersection);
+                        }
+                        intersection.add(element);
+                        partitionItem.delete(element);
+                        if (partitionItem.size === 0) {
+                            processed.delete(partitionItem);
+                        }
+                    }
+                }
+            }
+            const newPartitionItem = new Set(newPartitionCandidate);
+            for (const intersection of intersections.values()) {
+                processed.add(intersection);
+                for (const element of intersection) {
+                    newPartitionItem.delete(element);
+                }
+            }
+            intersections.clear();
+            if (newPartitionItem.size > 0) {
+                processed.add(newPartitionItem);
+            }
+        }
+        return processed;
+    };
+}
+
+module.exports = index;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export default function <T>(): (newPartitionCandidate?: Iterable<T> | undefined) => Iterable<Iterable<T>>;

package/dist/index.mjs

@@ -0,0 +1,38 @@
+function index () {
+    const processed = new Set();
+    return (newPartitionCandidate) => {
+        if (newPartitionCandidate) {
+            const intersections = new Map();
+            for (const element of newPartitionCandidate) {
+                for (const partitionItem of processed) {
+                    if (partitionItem.has(element)) {
+                        let intersection = intersections.get(partitionItem);
+                        if (intersection === undefined) {
+                            intersection = new Set();
+                            intersections.set(partitionItem, intersection);
+                        }
+                        intersection.add(element);
+                        partitionItem.delete(element);
+                        if (partitionItem.size === 0) {
+                            processed.delete(partitionItem);
+                        }
+                    }
+                }
+            }
+            const newPartitionItem = new Set(newPartitionCandidate);
+            for (const intersection of intersections.values()) {
+                processed.add(intersection);
+                for (const element of intersection) {
+                    newPartitionItem.delete(element);
+                }
+            }
+            intersections.clear();
+            if (newPartitionItem.size > 0) {
+                processed.add(newPartitionItem);
+            }
+        }
+        return processed;
+    };
+}
+
+export { index as default };

package/package.json

@@ -0,0 +1,65 @@
+{
+  "version": "1.0.0",
+  "license": "MIT",
+  "name": "@slimlib/refine-partition",
+  "author": "Konstantin Shutkin",
+  "type": "module",
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "typings": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=15"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kshutkin/slimlib.git"
+  },
+  "bugs": {
+    "url": "https://github.com/kshutkin/slimlib/issues"
+  },
+  "homepage": "https://github.com/kshutkin/slimlib/blob/main/refine-partition/README.md",
+  "readme": "README.md",
+  "description": "Simple refine partition implementation",
+  "keywords": [
+    "@slimlib",
+    "list",
+    "linked list",
+    "doubly linked list"
+  ],
+  "scripts": {
+    "build": "pkgbld",
+    "test": "jest --collectCoverage",
+    "lint": "eslint ./src",
+    "semantic-release": "npx semantic-release"
+  },
+  "devDependencies": {
+    "@semantic-release/changelog": "6.0.1",
+    "@semantic-release/commit-analyzer": "9.0.2",
+    "@semantic-release/git": "10.0.1",
+    "@semantic-release/npm": "9.0.0",
+    "@semantic-release/release-notes-generator": "10.0.3",
+    "@types/jest": "27.4.0",
+    "@typescript-eslint/eslint-plugin": "5.11.0",
+    "@typescript-eslint/parser": "5.11.0",
+    "conventional-changelog-angular": "5.0.13",
+    "eslint": "8.8.0",
+    "jest": "27.5.1",
+    "semantic-release": "19.0.2",
+    "semantic-release-monorepo": "7.0.5",
+    "ts-jest": "27.1.3",
+    "typescript": "4.5.x",
+    "update-monorepo-package-json": "0.2.0",
+    "pkgbld": "1.1.9"
+  },
+  "dependencies": {}
+}