@design-edito/tools 0.4.5 → 0.4.6

package/TODO.md

@@ -0,0 +1,269 @@
+# To do
+
+# -
+
+Après le dev :
+- envoyer le code à GPT + Claude, leur demander:
+  1/ s'ils comprennent le fichier, on veut juste s'assurer qu'on est raccord avec lui à ce stade
+  2/ en gardant en tête de garder le périmètre fonctionnel intact, sans chercher à faire plus ce qu'il y a actuellement, de relever les nommages ou formes de code qui pourraient être améliorées pour que le fichier soit prêt à intégrer une librairie de composants solide, durable dans le temps et facile à maintenir. Préciser qu'il faut respecter les règles de standardjs pour le lint
+- essayer de build, régler les erreurs du linter
+- après ça, fournir à GPT/Claude un exemple de fichier test d'un autre composant, Drawer par ex, + le code actuel de Subtitles, et lui demander de garder le style/approche fourni, et générer les tests pertinents pour le composant Subtitles (utiliser srtFileContents et pas src, ça va être une galère). Lui rappeler que les tests sont évalués par nodejs, donc pas trop se reposer sur des choses qui se passent dans un browser. Pas trop besoin de checker le contenu du fichier de test, moi je prends ce qu'il me donne, je lance le test et espère que ça passe tout, si ça passe pas tu peux lui donner le contenu de l'erreur et voir si il arrive à régler le truc tout seul, si ça veut vraiment pas, commente l'intégralité du test qui bloque, tant pis.
+- ensuite une fois que c'est bon, fournir à GPT/Claude un exemple de JSDOC issu d'un autre composant, Gallery par ex, + le code actuel de Subtitles, et lui demander de générer le JSDOC pour tous les exported members de Subtitles (Props et Subtitles à priori). Juste le JSDOC, pas répéter le code, parfois en générant tout il glisse des erreurs en répétant le code.
+- re build, lint et corrections éventuelles des erreurs du linter
+- pull add commit push 🎉
+
+
+# Composants
+
+## Composant Vidéo
+
+/components/Video
+
+
+### D'abord, on va reprendre new-app/src/components/VideoPlayer/MutedVideo.tsx
+Ce composant permet un workaround d'une petite bizzarerie de react avec l'attribut muted.
+Ça va être notre composant vidéo de base, pour ne pas manipuler directement l'élément html vidéo.
+
+### Ensuite, un composant tout simple :
+
+// "on" evt listeners
+// "state/props"
+// "int/obs triggers"
+// disclaimer
+// subs
+
+- une vidéo :
+```tsx
+type SourceData = {
+  src?: string
+  type?: string
+}
+type TrackData = {
+  src?: string
+  kind?: 'subtitles' | 'captions' | 'descriptions' | 'chapters' | 'metadata'
+  srclang?: string
+  label?: string
+  default?: boolean
+}
+type Props = {
+  sources?: string | string[] | SourceData[] // liste des éléments <source> dans la vidéo (ignore si pas src dans SourceData)
+  tracks?: string | string[] | TrackData[] // liste des éléments <tracks> dans la vidéo (ignore si pas src dans TrackData)
+  children?: JSX.Element // react children habituel, vient se coller sous les <source> et <tracks>
+} & VideoHTMLAttributes<HTMLVideoElement>
+
+const {
+  sources,
+  tracks,
+  children,
+  ...intrinsicVideoAttributes
+} = props
+```
+- un bouton play
+  - sur lm-video :
+  - data-play-on
+  - lm-video--play-on
+- un bouton pause
+  - sur lm-video :
+  - data-play-off
+  - lm-video--play-off
+- un span "temps écoulé"
+  - sur lm-video :
+  - data-elapsed-time-percent (0-1)
+  - data-elapsed-time-ms
+  - data-elapsed-time-readable ((hh:)mm:ss)
+- un span "temps total"
+  - sur lm-video :
+  - data-total-time-ms
+  - data-total-time-readable
+- une div cliquable en guise de timeline (pas de curseur)
+- un bouton sound on
+  - sur lm-video:
+  - data-sound-on
+  - lm-video--sound-on
+- un bouton sound off
+  - sur lm-video:
+  - data-sound-off
+  - lm-video--sound-off
+- un input range (0 - 100, step=1) pour piloter le son
+  - sur lm-video:
+  - data-sound-volume-percent (0-1) (ne se met pas à 0 si sound off, c'est deux données séparées)
+  - data-sound-volume-readable (0-100)
+- un span "volume (0-100)"
+- un bouton full screen
+  - sur lm-video:
+  - data-fullscreen-on / data-full-screen-off
+  - lm-video--fullscreen-on / lm-video--fullscreen-off
+- un bouton download
+- un input range playback-speed (0.25-4 step=0.25)
+  - sur lm-video:
+  - data-playback-speed (.25-4)
+- un span "playback speed (.25-4)"
+
+### Suite [WIP]
+
+[ ] Click sur timeline ne semble pas marcher ?
+[ ] 
+
+- Gérer la partie "controlled behavior" tout d'un coup
+[ ] Idée : quand la vidéo est en mode controlled, 
+
+
+
+
+
+
+## Composant Subtitles
+
+lm-tools/src/components/Subtitles/index.tsx
+
+```tsx
+<Subtitles
+  src='srt.file.url'
+  srtFileContent='Contenu srt brut, si présent la prop src est ignorée.'
+  subsGroups={[3, 4, 5]}
+  timecodeMs={10000}>
+</Subtitles>
+```
+
+```html
+<div class="dsed-subtitles">
+  <!-- Groupe passé (donc que sub prev dedans) -->
+  <div
+    class="dsed-subtitles__group dsed-subtitles__group--prev"
+    data-start-sub-pos="0"
+    data-end-sub-pos="1">
+    <span class="dsed-subtitles__sub dsed-subtitles__sub--prev" data-sub-pos="0">
+      Some sub
+    </span>
+  </div>
+  <!-- Groupe courant (mix de sub prev, curr et next) -->
+  <div
+    class="dsed-subtitles__group dsed-subtitles__group--curr"
+    data-start-timecode="00:02:16,612"
+    data-end-timecode="00:02:16,612"
+    data-start-time-ms="34754382"
+    data-end-time-ms="34754382"
+    data-start-sub-pos="0"
+    data-end-sub-pos="1">
+    <span
+      class="dsed-subtitles__sub dsed-subtitles__sub--curr"
+      data-start-timecode="00:02:16,612"
+      data-end-timecode="00:02:16,612"
+      data-start-time-ms="34754382"
+      data-end-time-ms="34754382">
+      Some sub
+    </span>
+  </div>
+  <!-- Groupe à venir -->
+  <div
+    class="dsed-subtitles__group dsed-subtitles__group--prev"
+    data-start-timecode="00:02:16,612"
+    data-end-timecode="00:02:16,612"
+    data-start-time-ms="34754382"
+    data-end-time-ms="34754382"
+    data-start-sub-pos="0"
+    data-end-sub-pos="1">
+    <span
+      class="dsed-subtitles__sub dsed-subtitles__sub--prev"
+      data-start-timecode="00:02:16,612"
+      data-end-timecode="00:02:16,612"
+      data-start-time-ms="34754382"
+      data-end-time-ms="34754382">
+      Some sub
+    </span>
+  </div>
+</div>
+```
+
+
+
+
+# CLI Utils
+
+
+## Get diff from commit hash
+
+```ts
+export type GetDiffOptions = {
+  cwd?: string
+}
+
+// Pas certain de Array<string> mais c'est peut-être suffisant,
+// l'idée c'est d'avoir une liste descriptive des changements successifs sur un fichier (genre le contenu brut de git diff)
+export type Diff = Record<string, Array<string>>
+
+// Ou pas async si pas nécessaire
+export async function getDiffFrom (
+  commitHash: string,
+  options: GetDiffOptions = {}
+): Promise<Diff> {
+  const { cwd } = options
+  return {}
+}
+```
+
+## Generate commit message from diff
+
+```ts
+export type GenerateDiffDescriptionOptions = {
+  customPromptOrSomething?: string // juste une idée comme ça, sais pas si c'est pertinent
+  // Ptet c'est là qu'il faut dire "je veux plutôt un changelog, ou plutôt un message de commit"
+}
+
+export async function generateDiffDescription (
+  diff: Diff,
+  options: GenerateDiffDescriptionOptions = {}): Promise<string> {
+  return ''
+}
+```
+
+
+
+
+# Tests & JSDOC
+
+- [ ] Tests manquants (garder la forme describe('funcName') { it('does something') {} })
+  - [ ] agnostic/html/hyper-json -> nécessaire mais trop compliqué/long
+  - [ ] agnostic/html/placeholders -> pas nécessaire
+  - [ ] agnostic/misc/logs/make-text-block -> Manque JSDOC aussi
+  - [ ] agnostic/strings/char-codes
+  - [ ] agnostic/strings/matches
+  - [ ] agnostic/strings/parse-table
+  - [ ] agnostic/strings/to-alphanum
+  - [ ] agnostic/strings/trim
+  - [ ] agnostic/time/dates/format-date
+  - [ ] agnostic/time/duration
+  - [ ] agnostic/time/timeout
+  - [ ] agnostic/time/transitions
+  - [ ] agnostic/time/wait
+  - [ ] node/@aws-s3 - oui mais comment (valable aussi pour gcs, ftps & sftp) ?
+  - [ ] node/@design-edito - vide
+  - [ ] node/@express/@multer
+  - [ ] node/@google-cloud
+  - [ ] node/cloud-storage
+  - [ ] node/encryption
+  - [ ] node/files
+  - [ ] node/ftps
+  - [ ] node/images
+  - [ ] node/process
+  - [ ] node/sftp
+
+  - Pas utile
+  - [ ] agnostic/css/bem -> DEPRECATED
+  - [ ] agnostic/css/styles-set -> DEPRECATED
+  - [ ] agnostic/errors/register -> pas nécessaire
+  - [ ] agnostic/html/sanitization/html -> DEPRECATED
+  - [ ] agnostic/misc/assert -> DEPRECATED
+  - [ ] agnostic/misc/logs/logger -> presque DEPRECATED
+  - [ ] agnostic/misc/logs/styles -> pas nécessaire tout de suite
+  - [ ] agnostic/strings/normalize-indent -> pas nécessaire tout de suite, fonction à repenser
+  - [ ] agnostic/strings/replace-all -> DEPRECATED
+
+
+
+# Misc
+
+- [ ] Repenser agnostic/optim/throttle-debounce ?
+- [ ] Repenser agnostic/strings/normalize-indent ?
+- [ ] Get rid of namespaces in hyper-json ?
+- [ ] agnostic/misc/logs/styles, se repencher dessus, viser à substituer totalement chalk (styles génériques, bold, red, bgBlue, etc...) + continuer à exporter des "styles nommés" comme actuellement

package/agnostic/arrays/dedupe/index.js

@@ -1,8 +1,10 @@
-// src/agnostic/arrays/dedupe/index.ts
-function dedupe(arr) {
-  const deduped = Array.from(new Set(arr));
-  return deduped;
+/**
+ * Returns a copy of the input array, with stripped duplicates
+ *
+ * @param arr - The array to search for duplicates.
+ * @returns The deduped array
+ */
+export function dedupe(arr) {
+    const deduped = Array.from(new Set(arr));
+    return deduped;
 }
-export {
-  dedupe
-};

package/agnostic/arrays/dedupe/index.test.js

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest';
+import { dedupe } from './index.js';
+describe('dedupe', () => {
+    it('preserves arrays without duplicates', () => {
+        const result = dedupe([1, 2, 3]);
+        expect(result).toHaveLength(3);
+        expect(result).toContain(1);
+        expect(result).toContain(2);
+        expect(result).toContain(3);
+    });
+    it('removes duplicates', () => {
+        const dupObj = { b: 1 };
+        const result = dedupe([
+            1, 1, 2,
+            'a', 'a', 'b',
+            true, true, false,
+            null, null,
+            undefined, undefined,
+            { a: 1 }, { a: 1 },
+            dupObj, dupObj
+        ]);
+        expect(JSON.stringify(result)).toEqual('[1,2,"a","b",true,false,null,null,{"a":1},{"a":1},{"b":1}]');
+    });
+});

package/agnostic/arrays/find-duplicates/index.js

@@ -1,24 +1,36 @@
-// src/agnostic/arrays/find-duplicates/index.ts
-function findDuplicates(arr, stopAtFirst = false) {
-  const seen = /* @__PURE__ */ new Set();
-  const duplicates = /* @__PURE__ */ new Set();
-  for (const item of arr) {
-    if (seen.has(item) && stopAtFirst) return [item];
-    if (seen.has(item)) duplicates.add(item);
-    seen.add(item);
-  }
-  return Array.from(duplicates);
+// [WIP] could provide an equality check optional function for checking mor complex objects
+/**
+ * Finds duplicate elements in an array.
+ *
+ * @param arr - The array to search for duplicates.
+ * @param [stopAtFirst=false] - If `true`, returns immediately after finding the first duplicate.
+ * @returns An array of duplicate elements found in the input array.
+ */
+export function findDuplicates(arr, stopAtFirst = false) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const item of arr) {
+        if (seen.has(item) && stopAtFirst)
+            return [item];
+        if (seen.has(item))
+            duplicates.add(item);
+        seen.add(item);
+    }
+    return Array.from(duplicates);
 }
-function findDuplicatesPositions(arr) {
-  const seen = /* @__PURE__ */ new Set();
-  const duplicatesPos = [];
-  arr.forEach((item, pos) => {
-    if (seen.has(item)) return duplicatesPos.push(pos);
-    seen.add(item);
-  });
-  return duplicatesPos;
+/**
+ * Finds the positions of duplicate elements in an array.
+ *
+ * @param arr - The array to search for duplicates positions.
+ * @returns An array of the positions of duplicate elements found in the input array.
+ */
+export function findDuplicatesPositions(arr) {
+    const seen = new Set();
+    const duplicatesPos = [];
+    arr.forEach((item, pos) => {
+        if (seen.has(item))
+            return duplicatesPos.push(pos);
+        seen.add(item);
+    });
+    return duplicatesPos;
 }
-export {
-  findDuplicates,
-  findDuplicatesPositions
-};

package/agnostic/arrays/find-duplicates/index.test.js

@@ -0,0 +1,31 @@
+import { describe, it, expect } from 'vitest';
+import { findDuplicates, findDuplicatesPositions } from './index.js';
+describe('find-duplicates', () => {
+    it('finds no duplicates when there are none', () => {
+        const result = findDuplicates([1, 2, 3]);
+        expect(result).toHaveLength(0);
+    });
+    it('finds duplicates and stops at first when asked', () => {
+        const result = findDuplicates([1, 1, 2, 2], true);
+        expect(result).toHaveLength(1);
+        expect(result).toContain(1);
+    });
+    it('finds all duplicates otherwise', () => {
+        const result = findDuplicates([1, 1, 2, 2]);
+        expect(result).toHaveLength(2);
+        expect(result).toContain(1);
+        expect(result).toContain(2);
+    });
+});
+describe('find-duplicates-positions', () => {
+    it('finds no duplicates positions when there are no duplicates', () => {
+        const result = findDuplicatesPositions([1, 2, 3]);
+        expect(result).toHaveLength(0);
+    });
+    it('finds all duplicates positions', () => {
+        const result = findDuplicatesPositions([1, 1, 2, 2]);
+        expect(result).toHaveLength(2);
+        expect(result).toContain(1);
+        expect(result).toContain(3);
+    });
+});

package/agnostic/arrays/index.d.ts

@@ -1,6 +1,6 @@
 export * as dedupe from './dedupe/index.js'
+export * as isArrayOf from './is-array-of/index.js'
+export * as findDuplicates from './find-duplicates/index.js'
 export * as make from './make/index.js'
 export * as randomPick from './random-pick/index.js'
 export * as shuffle from './shuffle/index.js'
-export * as findDuplicates from './find-duplicates/index.js'
-export * as isArrayOf from './is-array-of/index.js'

package/agnostic/arrays/index.js

@@ -1,6 +1,6 @@
 export * as dedupe from './dedupe/index.js'
+export * as isArrayOf from './is-array-of/index.js'
+export * as findDuplicates from './find-duplicates/index.js'
 export * as make from './make/index.js'
 export * as randomPick from './random-pick/index.js'
 export * as shuffle from './shuffle/index.js'
-export * as findDuplicates from './find-duplicates/index.js'
-export * as isArrayOf from './is-array-of/index.js'

package/agnostic/arrays/is-array-of/index.js

@@ -1,27 +1,29 @@
-// src/agnostic/misc/is-constructor-function/index.ts
-function isConstructorFunction(input) {
-  return typeof input === "function" && "prototype" in input && typeof input.prototype === "object" && "constructor" in input.prototype && input.prototype.constructor === input;
+import { isConstructorFunction } from '../../misc/is-constructor-function/index.js';
+/**
+ * Type guard to check if an input is an array and optionally if all elements match a type.
+ *
+ * If no type checkers are provided, only checks if the input is an array.
+ * Supports constructor functions (e.g., `Number`, `String`, `Boolean`, custom classes)
+ * and custom type guard functions.
+ */
+export function isArrayOf(input, _types) {
+    if (!Array.isArray(input))
+        return false;
+    if (_types === undefined)
+        return true;
+    const types = Array.isArray(_types) ? _types : [_types];
+    const primitiveTypeMap = new Map([
+        [Number, 'number'],
+        [String, 'string'],
+        [Boolean, 'boolean']
+    ]);
+    return input.every(entry => types.some(typeChecker => {
+        if (!isConstructorFunction(typeChecker))
+            return typeChecker(entry);
+        const primitiveType = primitiveTypeMap.get(typeChecker);
+        // eslint-disable-next-line valid-typeof
+        if (primitiveType !== undefined)
+            return typeof entry === primitiveType;
+        return entry instanceof typeChecker;
+    }));
 }
-
-// src/agnostic/arrays/is-array-of/index.ts
-function isArrayOf(input, _types) {
-  if (!Array.isArray(input)) return false;
-  if (_types === void 0) return true;
-  const types = Array.isArray(_types) ? _types : [_types];
-  const primitiveTypeMap = /* @__PURE__ */ new Map([
-    [Number, "number"],
-    [String, "string"],
-    [Boolean, "boolean"]
-  ]);
-  return input.every(
-    (entry) => types.some((typeChecker) => {
-      if (!isConstructorFunction(typeChecker)) return typeChecker(entry);
-      const primitiveType = primitiveTypeMap.get(typeChecker);
-      if (primitiveType !== void 0) return typeof entry === primitiveType;
-      return entry instanceof typeChecker;
-    })
-  );
-}
-export {
-  isArrayOf
-};

package/agnostic/arrays/is-array-of/index.test.js

@@ -0,0 +1,56 @@
+import { describe, it, expect } from 'vitest';
+import { isArrayOf } from './index.js';
+// Custom class & typeguard for testing
+class MyClass {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+const isEvenNumber = (x) => typeof x === 'number' && x % 2 === 0;
+describe('is-array-of', () => {
+    it('returns true for empty array without type checkers', () => {
+        expect(isArrayOf([])).toBe(true);
+    });
+    it('returns true for array of numbers', () => {
+        expect(isArrayOf([1, 2, 3], Number)).toBe(true);
+    });
+    it('returns false if any element does not match primitive type', () => {
+        expect(isArrayOf([1, '2', 3], Number)).toBe(false);
+        expect(isArrayOf([true, false, 0], Boolean)).toBe(false);
+        expect(isArrayOf(['a', 'b', 1], String)).toBe(false);
+    });
+    it('returns true for array of strings', () => {
+        expect(isArrayOf(['a', 'b', 'c'], String)).toBe(true);
+    });
+    it('returns true for array of booleans', () => {
+        expect(isArrayOf([true, false, true], Boolean)).toBe(true);
+    });
+    it('returns true for array of custom class instances', () => {
+        const arr = [new MyClass(1), new MyClass(2)];
+        expect(isArrayOf(arr, MyClass)).toBe(true);
+    });
+    it('returns false if any element is not instance of custom class', () => {
+        const arr = [new MyClass(1), { value: 2 }];
+        expect(isArrayOf(arr, MyClass)).toBe(false);
+    });
+    it('supports multiple type checkers (union)', () => {
+        const arr = [1, 'a', 2, 'b'];
+        expect(isArrayOf(arr, [Number, String])).toBe(true);
+        expect(isArrayOf([1, true], [Number, String])).toBe(false);
+    });
+    it('supports custom type guard functions', () => {
+        const arr = [2, 4, 6];
+        expect(isArrayOf(arr, isEvenNumber)).toBe(true);
+        expect(isArrayOf([2, 3, 4], isEvenNumber)).toBe(false);
+    });
+    it('returns false for non-array input', () => {
+        expect(isArrayOf(123, Number)).toBe(false);
+        expect(isArrayOf({}, Number)).toBe(false);
+        expect(isArrayOf(null, Number)).toBe(false);
+        expect(isArrayOf(undefined, Number)).toBe(false);
+    });
+    it('returns true for array without type checkers', () => {
+        expect(isArrayOf([1, 'a', true])).toBe(true);
+    });
+});

package/agnostic/arrays/make/index.js

@@ -1,7 +1,12 @@
-// src/agnostic/arrays/make/index.ts
-function make(filler, length) {
-  return new Array(length).fill(null).map((_, pos) => filler(pos));
+/**
+ * Creates an array of a specified length using a filler function.
+ *
+ * @param filler - Function called for each position to generate the array element.
+ * @param length - Desired length of the array.
+ * @returns A new array with elements generated by the filler function.
+ */
+export function make(filler, length) {
+    return new Array(length)
+        .fill(null)
+        .map((_, pos) => filler(pos));
 }
-export {
-  make
-};

package/agnostic/arrays/make/index.test.js

@@ -0,0 +1,10 @@
+import { describe, it, expect } from 'vitest';
+import { make } from './index.js';
+import { randomInt } from '../../random/random/index.js';
+describe('make', () => {
+    it('makes the array', () => {
+        const made = make(() => randomInt(0, 42), 4);
+        expect(made).toHaveLength(4);
+        expect(made.every(i => typeof i === 'number')).toBe(true);
+    });
+});

package/agnostic/arrays/random-pick/index.js

@@ -1,24 +1,40 @@
-// src/agnostic/arrays/random-pick/index.ts
-function randomPick(arr, exclude = []) {
-  const filteredArr = [...arr].filter((elt) => !exclude.includes(elt));
-  const length = filteredArr.length;
-  if (length === 0) throw new Error("Array length must be at least 1 after exclusion");
-  const pos = Math.floor(Math.random() * length);
-  const found = filteredArr[pos];
-  return found;
+/**
+ * Picks a random element from an array, optionally excluding certain elements.
+ *
+ * @param arr - The array to pick from.
+ * @param [exclude] - Array of elements to exclude from selection.
+ * @returns A randomly selected element from the array.
+ * @throws Throws an error if no elements are available after exclusions.
+ */
+export function randomPick(arr, exclude = []) {
+    const filteredArr = [...arr].filter(elt => !exclude.includes(elt));
+    const length = filteredArr.length;
+    if (length === 0)
+        throw new Error('Array length must be at least 1 after exclusion');
+    const pos = Math.floor(Math.random() * length);
+    const found = filteredArr[pos];
+    return found;
 }
-function randomPickMany(howMuch, arr, exclude = []) {
-  const grindedArr = [...arr];
-  const pickedSelection = [];
-  for (let i = 0; i < howMuch; i++) {
-    const picked = randomPick(grindedArr, exclude);
-    const indexOfPicked = grindedArr.indexOf(picked);
-    grindedArr.splice(indexOfPicked, 1);
-    pickedSelection.push(picked);
-  }
-  return pickedSelection;
+/**
+ * Picks multiple random elements from an array without replacement.
+ *
+ * Each picked element is removed from the pool before the next selection, ensuring
+ * no duplicates in the result.
+ *
+ * @param howMuch - Number of elements to pick.
+ * @param arr - The array to pick from.
+ * @param [exclude] - Array of elements to exclude from selection.
+ * @returns An array of randomly selected elements.
+ * @throws Propagates the error thrown by `randomPick` if not enough elements are available.
+ */
+export function randomPickMany(howMuch, arr, exclude = []) {
+    const grindedArr = [...arr];
+    const pickedSelection = [];
+    for (let i = 0; i < howMuch; i++) {
+        const picked = randomPick(grindedArr, exclude);
+        const indexOfPicked = grindedArr.indexOf(picked);
+        grindedArr.splice(indexOfPicked, 1);
+        pickedSelection.push(picked);
+    }
+    return pickedSelection;
 }
-export {
-  randomPick,
-  randomPickMany
-};

package/agnostic/arrays/random-pick/index.test.js

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import { randomPick, randomPickMany } from './index.js';
+import { make } from '../make/index.js';
+describe('random-pick', () => {
+    it('correctly picks one', () => {
+        const source = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+        const pickedOneTenTimes = make(() => randomPick(source), 10);
+        expect(pickedOneTenTimes.every(picked => source.includes(picked)));
+    });
+    it('throws if asked to pick more than there are in the input', () => {
+        expect(() => randomPick([])).toThrow();
+    });
+});
+describe('random-pick-many', () => {
+    it('correctly picks one and many', () => {
+        const source = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+        const pickedManyTenTimes = make(() => randomPickMany(3, source), 10);
+        expect(pickedManyTenTimes.every(picked => picked.every(p => source.includes(p))));
+    });
+    it('throws if asked to pick more than there are in the input', () => {
+        expect(() => randomPickMany(2, [0])).toThrow();
+    });
+});