@fusion.dev/helix-core 0.145.0 → 0.147.0

package/dist/utils/written-list/written-list.d.ts

@@ -61,3 +61,63 @@ export declare const commaList: (value: string) => string[];
  * holds, so a set of pressed items reads the same whichever was pressed first.
  */
 export declare const toggleValue: (list: readonly string[], value: string, order?: readonly string[]) => string[];
+/**
+ * `chosen` with every one of `values` added, or with every one taken out
+ * where each was already in it: a select-all box, or a branch of a checkbox
+ * tree pressed. `values` empty changes nothing.
+ *
+ * With `order`, the result is put in that order and holds only what `order`
+ * holds. Without it, what was chosen keeps its place and what is added
+ * follows.
+ */
+export declare const toggleEvery: (chosen: Iterable<string>, values: readonly string[], order?: readonly string[]) => string[];
+/**
+ * What a select-all box shows for `values`: checked when every one is
+ * chosen, mixed when some are, and neither for none or an empty set.
+ *
+ * Checkbox Group's select-all box and the header boxes of Table and Data
+ * Table each worked this out. A set that does not count its disabled boxes
+ * passes only the enabled values.
+ */
+export declare const everyState: (chosen: Iterable<string>, values: readonly string[]) => {
+    checked: boolean;
+    indeterminate: boolean;
+};
+/**
+ * `keys` in the order the rows are, which is `order`: the keys of the whole
+ * set. A key the set does not hold, a selected row a search has hidden say,
+ * keeps its place after them in the order it was given.
+ *
+ * So a selection reads in row order whatever order its rows were chosen in:
+ * Data Table's, and Table's and Virtual List's, which wrote it in press order
+ * or wrote this again.
+ */
+export declare const inRowOrder: (keys: Iterable<string>, order: readonly string[]) => string[];
+/**
+ * Where a Shift range runs from, as an index into `keys`: the row last chosen
+ * while it is among them, and otherwise the row the reader is on, `from`,
+ * which becomes the one to run from.
+ */
+export declare const anchorAt: (keys: readonly string[], anchorKey: string | undefined, from: number) => {
+    anchor: number;
+    anchorKey: string | undefined;
+};
+/** How many items a set lets a reader select: Tag Group's and List's `selection-mode`. */
+export type SelectionMode = 'multiple' | 'none' | 'single';
+/**
+ * The comma-separated `value` a press on the item carrying `pressed` leaves.
+ *
+ * `single` selects that item alone, or none where it was the one selected.
+ * `multiple` adds it, or takes it out. `none` selects nothing and leaves the
+ * value as it was. Tag Group and List answer the same question for their
+ * tags and rows.
+ */
+export declare const pressedValue: (mode: SelectionMode, value: string, pressed: string) => string;
+/**
+ * The comma-separated `value` once an item carrying `removed` has left, where
+ * `left` is what the items still there stand for.
+ *
+ * Taken out only where no item left still stands for it, so two items with
+ * one value keep it while either remains. The rest is written back as it was.
+ */
+export declare const prunedValue: (value: string, removed: string, left: readonly string[]) => string;

package/dist/utils/written-list/written-list.js

@@ -12,3 +12,49 @@ export const toggleValue = (list, value, order) => {
     const next = list.includes(value) ? list.filter((one) => one !== value) : [...list, value];
     return order ? order.filter((one) => next.includes(one)) : next;
 };
+export const toggleEvery = (chosen, values, order) => {
+    const next = new Set(chosen);
+    const every = values.length > 0 && values.every((value) => next.has(value));
+    for (const value of values) {
+        if (every) {
+            next.delete(value);
+        }
+        else {
+            next.add(value);
+        }
+    }
+    return order ? order.filter((value) => next.has(value)) : [...next];
+};
+export const everyState = (chosen, values) => {
+    const held = new Set(chosen);
+    const count = values.filter((value) => held.has(value)).length;
+    const checked = values.length > 0 && count === values.length;
+    return { checked, indeterminate: count > 0 && !checked };
+};
+export const inRowOrder = (keys, order) => {
+    const wanted = new Set(keys);
+    const placed = order.filter((key) => wanted.has(key));
+    const seen = new Set(placed);
+    return [...placed, ...[...wanted].filter((key) => !seen.has(key))];
+};
+export const anchorAt = (keys, anchorKey, from) => {
+    const anchor = anchorKey === undefined ? -1 : keys.indexOf(anchorKey);
+    return anchor < 0 ? { anchor: from, anchorKey: keys[from] } : { anchor, anchorKey };
+};
+export const pressedValue = (mode, value, pressed) => {
+    const now = commaList(value);
+    if (mode === 'single') {
+        return now.includes(pressed) ? '' : pressed;
+    }
+    if (mode === 'multiple') {
+        return toggleValue(now, pressed).join(', ');
+    }
+    return value;
+};
+export const prunedValue = (value, removed, left) => {
+    const now = commaList(value);
+    if (!now.includes(removed) || left.includes(removed)) {
+        return value;
+    }
+    return now.filter((one) => one !== removed).join(', ');
+};

package/dist/version.d.ts

@@ -6,4 +6,4 @@
  * release, so the two never disagree; a spec beside this holds them to it.
  * Nothing else in the running code knows which release it is.
  */
-export declare const VERSION = "0.145.0";
+export declare const VERSION = "0.147.0";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.145.0';
+export const VERSION = '0.147.0';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fusion.dev/helix-core",
   "description": "Helix element primitives: base classes, mixins, decorators, utilities.",
-  "version": "0.145.0",
+  "version": "0.147.0",
   "license": "MIT",
   "author": "Ross Sheppard <ross.sheppard@fusion.dev>",
   "repository": {
@@ -28,21 +28,45 @@
   "scripts": {
     "analyze": "bun --bun helix-cem",
     "build": "tsc -p tsconfig.build.json && tsc -p tsconfig.types.json",
-    "test": "bun test src",
+    "test": "bun test src --conditions helix-source --conditions helix-development",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "bugs": "https://github.com/project-fusion/fusion/issues",
   "dependencies": {
     "@floating-ui/dom": "^1.8.0",
-    "@fusion.dev/helix-icons": "0.145.0"
+    "@fusion.dev/helix-icons": "0.147.0"
   },
   "devDependencies": {
-    "@fusion.dev/helix-cem": "0.145.0",
-    "@fusion.dev/helix-testing": "0.145.0",
+    "@fusion.dev/helix-cem": "0.147.0",
+    "@fusion.dev/helix-testing": "0.147.0",
     "@lit-labs/ssr": "^4.1.0",
     "lit": "^3.2.1"
   },
   "homepage": "https://fusion.dev",
+  "imports": {
+    "#audit-name": {
+      "helix-source": {
+        "development": "./src/utils/audit-name/audit-name.ts",
+        "helix-development": "./src/utils/audit-name/audit-name.ts",
+        "default": "./src/utils/audit-name/audit-name-off.ts"
+      },
+      "types": "./dist/utils/audit-name/audit-name.d.ts",
+      "development": "./dist/utils/audit-name/audit-name.js",
+      "helix-development": "./dist/utils/audit-name/audit-name.js",
+      "default": "./dist/utils/audit-name/audit-name-off.js"
+    },
+    "#audit-source": {
+      "helix-source": {
+        "development": "./src/utils/audit-source/audit-source.ts",
+        "helix-development": "./src/utils/audit-source/audit-source.ts",
+        "default": "./src/utils/audit-source/audit-source-off.ts"
+      },
+      "types": "./dist/utils/audit-source/audit-source.d.ts",
+      "development": "./dist/utils/audit-source/audit-source.js",
+      "helix-development": "./dist/utils/audit-source/audit-source.js",
+      "default": "./dist/utils/audit-source/audit-source-off.js"
+    }
+  },
   "keywords": [
     "web-components",
     "custom-elements",