@conduction/docusaurus-preset 3.40.0 → 3.41.1

package/src/components/Redaction/__tests__/engine.test.js

@@ -0,0 +1,162 @@
+/**
+ * engine.test.js — the redaction rules.
+ *
+ * The asymmetry is the game: missing something costs a life, blacking
+ * out too much costs points. A version that scored both the same would
+ * teach people to black out the whole page, which is the other way of
+ * failing at this job.
+ *
+ * The second property is that every document has something to find. A
+ * document with no secrets in it is a free life the player cannot tell
+ * apart from a trap.
+ */
+
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+  createGame, black, publish, step, clockMs, remaining, summarise,
+  DOCUMENTS, DEFAULTS,
+} = require('../engine.js');
+
+/** Black out every secret in the current document. */
+function redactAll(state) {
+  let s = state;
+  s.doc.tokens.forEach((token, i) => { if (token.secret) s = black(s, i); });
+  return s;
+}
+
+test('every document has something to find, and something that must stay', () => {
+  for (const doc of DOCUMENTS) {
+    const secrets = doc.tokens.filter((t) => t.secret).length;
+    const plain = doc.tokens.filter((t) => !t.secret).length;
+    assert.ok(secrets > 0, `${doc.key}: nothing to redact`);
+    assert.ok(plain > 0, `${doc.key}: nothing but secrets`);
+  }
+});
+
+test('a game starts with a document, a clock and three lives', () => {
+  const s = createGame({seed: 1, now: 0});
+  assert.ok(s.doc);
+  assert.equal(s.lives, DEFAULTS.lives);
+  assert.equal(s.doc.expiresAt - s.doc.startedAt, DEFAULTS.clockStartMs);
+  assert.equal(remaining(s, 0), 1);
+});
+
+test('publishing with every secret blacked out is clean, and pays', () => {
+  let s = createGame({seed: 2, now: 0});
+  const secrets = s.doc.tokens.filter((t) => t.secret).length;
+  s = publish(redactAll(s), 100);
+  assert.equal(s.published, 1);
+  assert.equal(s.clean, 1);
+  assert.equal(s.lives, DEFAULTS.lives);
+  assert.equal(s.score, secrets * DEFAULTS.pointsPerSecret + DEFAULTS.pointsPerClean);
+  assert.ok(s.doc, 'no next document was dealt');
+});
+
+test('leaving one secret visible is a breach, whatever else was right', () => {
+  let s = createGame({seed: 3, now: 0});
+  const secretIndexes = s.doc.tokens.map((t, i) => (t.secret ? i : -1)).filter((i) => i >= 0);
+  /* Catch all but the last one: the player did almost everything. */
+  secretIndexes.slice(0, -1).forEach((i) => { s = black(s, i); });
+  const before = s.score;
+  s = publish(s, 100);
+  assert.equal(s.lives, DEFAULTS.lives - 1);
+  assert.equal(s.breaches, 1);
+  assert.equal(s.score, before, 'a breach still paid for the ones that were caught');
+  assert.equal(s.published, 0, 'a breach counted as a published document');
+});
+
+test('blacking out ordinary text costs points, not a life', () => {
+  let s = createGame({seed: 4, now: 0});
+  const plain = s.doc.tokens.findIndex((t) => !t.secret);
+  s = black(redactAll(s), plain);
+  const secrets = s.doc.tokens.filter((t) => t.secret).length;
+  s = publish(s, 100);
+  assert.equal(s.lives, DEFAULTS.lives, 'over-redaction cost a life');
+  assert.equal(s.overRedacted, 1);
+  assert.equal(s.clean, 0, 'a striped page counted as clean');
+  assert.equal(
+    s.score,
+    secrets * DEFAULTS.pointsPerSecret + DEFAULTS.pointsPerClean - DEFAULTS.overRedactionPenalty,
+  );
+});
+
+test('a badly over-redacted page never costs more points than it earned', () => {
+  let s = createGame({seed: 5, now: 0, config: {pointsPerSecret: 1, pointsPerClean: 1, overRedactionPenalty: 50}});
+  s = redactAll(s);
+  s.doc.tokens.forEach((token, i) => { if (!token.secret) s = black(s, i); });
+  s = publish(s, 100);
+  assert.ok(s.score >= 0, 'the score went negative');
+});
+
+test('blacking out the same word twice changes nothing', () => {
+  let s = createGame({seed: 6, now: 0});
+  const i = s.doc.tokens.findIndex((t) => t.secret);
+  s = black(s, i);
+  const once = JSON.stringify(s.doc.tokens);
+  s = black(s, i);
+  assert.equal(JSON.stringify(s.doc.tokens), once);
+  assert.equal(black(s, 9999), s, 'a word that does not exist was blacked out');
+});
+
+test('the clock publishes the document for you, exactly as it would', () => {
+  let s = createGame({seed: 7, now: 0});
+  const expires = s.doc.expiresAt;
+  /* Do nothing: the secrets are still visible when it goes out. */
+  s = step(s, expires + 1);
+  assert.equal(s.lives, DEFAULTS.lives - 1);
+  assert.equal(s.breaches, 1);
+});
+
+test('a document finished in time is not published twice by the clock', () => {
+  let s = createGame({seed: 8, now: 0});
+  const expires = s.doc.expiresAt;
+  s = publish(redactAll(s), 100);
+  const published = s.published;
+  s = step(s, expires + 1);
+  assert.equal(s.published, published, 'the clock published the next document early');
+});
+
+test('three breaches end the run, and nothing publishes afterwards', () => {
+  let s = createGame({seed: 9, now: 0});
+  for (let i = 0; i < 3; i++) s = publish(s, 100 * i);
+  assert.equal(s.over, true);
+  assert.equal(s.lives, 0);
+  assert.equal(publish(s, 999).score, s.score);
+  assert.equal(black(s, 0), s);
+});
+
+test('the clock tightens with the score, down to a readable floor', () => {
+  const fresh = createGame({seed: 10, now: 0});
+  assert.equal(clockMs(fresh), DEFAULTS.clockStartMs);
+  assert.ok(clockMs({...fresh, score: 50}) < DEFAULTS.clockStartMs);
+  assert.equal(clockMs({...fresh, score: 5000}), DEFAULTS.clockFloorMs);
+});
+
+test('the countdown runs full to empty and never past either end', () => {
+  const s = createGame({seed: 11, now: 0});
+  assert.equal(remaining(s, 0), 1);
+  assert.ok(Math.abs(remaining(s, DEFAULTS.clockStartMs / 2) - 0.5) < 0.01);
+  assert.equal(remaining(s, DEFAULTS.clockStartMs * 4), 0);
+});
+
+test('a careful player clears documents rather than losing lives', () => {
+  let s = createGame({seed: 12, now: 0});
+  let t = 0;
+  for (let i = 0; i < 12 && !s.over; i++) {
+    s = publish(redactAll(s), t);
+    t += 200;
+  }
+  assert.equal(s.lives, DEFAULTS.lives);
+  assert.equal(s.published, 12);
+  assert.ok(s.score > 0);
+});
+
+test('the summary reads as a sentence in both locales', () => {
+  const s = {published: 7, clean: 5};
+  assert.match(summarise(s, 'en'), /7 documents out · 5 clean/);
+  assert.match(summarise(s, 'nl'), /7 documenten uit · 5 schoon/);
+});

package/src/components/Redaction/engine.js

@@ -0,0 +1,186 @@
+/**
+ * Redaction — the rules, with no DOM and no clock of its own.
+ *
+ * Filinq's game. A document is about to be published. Black out
+ * everything in it that may not go out, before it does. A name, a
+ * citizen number, an address, a bank account, a date of birth: leave
+ * one in and it is a data breach, black out the whole thing and you
+ * have published a page of stripes.
+ *
+ * Both mistakes cost, and they cost differently, which is the point.
+ * Missing something is a breach and ends the document. Over-redacting
+ * is a nuisance: it costs points, not the run.
+ *
+ * Time and randomness are injected. The component owns the clock.
+ */
+
+/* Every document is a list of tokens. `secret` marks what may not be
+   published; everything else is the sentence around it. The component
+   supplies the words. */
+export const DOCUMENTS = [
+  {
+    key: 'permit',
+    tokens: [
+      {t: 'permitIntro'}, {t: 'name', secret: true}, {t: 'permitMiddle'},
+      {t: 'address', secret: true}, {t: 'permitTail'}, {t: 'bsn', secret: true},
+      {t: 'permitEnd'},
+    ],
+  },
+  {
+    key: 'invoice',
+    tokens: [
+      {t: 'invoiceIntro'}, {t: 'company'}, {t: 'invoiceMiddle'},
+      {t: 'iban', secret: true}, {t: 'invoiceTail'}, {t: 'amount'},
+      {t: 'invoiceEnd'}, {t: 'email', secret: true},
+    ],
+  },
+  {
+    key: 'objection',
+    tokens: [
+      {t: 'objectionIntro'}, {t: 'name', secret: true}, {t: 'objectionMiddle'},
+      {t: 'birthdate', secret: true}, {t: 'objectionTail'}, {t: 'caseNumber'},
+      {t: 'objectionEnd'},
+    ],
+  },
+  {
+    key: 'report',
+    tokens: [
+      {t: 'reportIntro'}, {t: 'department'}, {t: 'reportMiddle'},
+      {t: 'phone', secret: true}, {t: 'reportTail'}, {t: 'name', secret: true},
+      {t: 'reportEnd'}, {t: 'policy'},
+    ],
+  },
+];
+
+export const DEFAULTS = {
+  lives: 3,
+  /* Reading a document takes longer than judging a card, and the whole
+     game is reading. The floor is where a fast reader still finishes
+     the page. */
+  clockStartMs: 14000,
+  clockFloorMs: 6000,
+  rampPerPoint: 45,
+  pointsPerSecret: 10,
+  pointsPerClean: 15,
+  overRedactionPenalty: 5,
+};
+
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return function random() {
+    a |= 0; a = (a + 0x6D2B79F5) | 0;
+    let t = Math.imul(a ^ (a >>> 15), 1 | a);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+/** How long this document gives you, at the current score. */
+export function clockMs(state) {
+  return Math.max(state.cfg.clockFloorMs, state.cfg.clockStartMs - state.score * state.cfg.rampPerPoint);
+}
+
+function deal(state, now) {
+  const doc = DOCUMENTS[Math.floor(state.random() * DOCUMENTS.length)];
+  return {
+    ...state,
+    doc: {
+      key: doc.key,
+      tokens: doc.tokens.map((token) => ({...token, blacked: false})),
+      startedAt: now,
+      expiresAt: now + clockMs(state),
+    },
+  };
+}
+
+export function createGame({seed = Date.now(), now = 0, config = {}} = {}) {
+  const cfg = {...DEFAULTS, ...config};
+  const base = {
+    cfg,
+    random: mulberry32(seed),
+    doc: null,
+    score: 0,
+    lives: cfg.lives,
+    published: 0,
+    clean: 0,
+    breaches: 0,
+    overRedacted: 0,
+    last: null,
+    over: false,
+  };
+  return deal(base, now);
+}
+
+export function remaining(state, now) {
+  if (!state.doc) return 0;
+  const total = state.doc.expiresAt - state.doc.startedAt;
+  if (total <= 0) return 0;
+  return Math.min(1, Math.max(0, (state.doc.expiresAt - now) / total));
+}
+
+/** Black out one token. Blacking out the same one twice is a no-op. */
+export function black(state, index) {
+  if (state.over || !state.doc) return state;
+  const token = state.doc.tokens[index];
+  if (!token || token.blacked) return state;
+  const tokens = [...state.doc.tokens];
+  tokens[index] = {...token, blacked: true};
+  return {...state, doc: {...state.doc, tokens}};
+}
+
+function loseLife(state, reason, now) {
+  const lives = state.lives - 1;
+  return {...state, lives, last: {result: reason, at: now}, over: lives <= 0};
+}
+
+/**
+ * Publish what is on the screen.
+ *
+ * Everything secret blacked out is a clean publication and pays a
+ * bonus. Anything secret left visible is a breach: a life, whatever
+ * else was done right. Blacking out ordinary text costs points per
+ * word, because a page of stripes is not a published document either.
+ */
+export function publish(state, now) {
+  if (state.over || !state.doc) return state;
+
+  const missed = state.doc.tokens.filter((t) => t.secret && !t.blacked).length;
+  const over = state.doc.tokens.filter((t) => !t.secret && t.blacked).length;
+  const caught = state.doc.tokens.filter((t) => t.secret && t.blacked).length;
+
+  if (missed > 0) {
+    const hit = {...loseLife(state, 'breach', now), breaches: state.breaches + 1, missed};
+    return hit.over ? {...hit, doc: null} : deal({...hit, doc: null}, now);
+  }
+
+  const gained = caught * state.cfg.pointsPerSecret
+    + state.cfg.pointsPerClean
+    - over * state.cfg.overRedactionPenalty;
+
+  const next = {
+    ...state,
+    /* A document can score badly, but publishing correctly never costs
+       points overall: the floor is zero for the page. */
+    score: state.score + Math.max(0, gained),
+    published: state.published + 1,
+    clean: over === 0 ? state.clean + 1 : state.clean,
+    overRedacted: state.overRedacted + over,
+    last: {result: over === 0 ? 'clean' : 'overRedacted', over, points: Math.max(0, gained), at: now},
+  };
+  return deal(next, now);
+}
+
+/** Let the clock run out: the document publishes itself, as it would. */
+export function step(state, now) {
+  if (state.over || !state.doc) return state;
+  if (now < state.doc.expiresAt) return state;
+  return publish(state, now);
+}
+
+/** The line that goes on the game-over card and into the post. */
+export function summarise(state, locale = 'en') {
+  const n = (v) => Number(v || 0).toLocaleString(locale);
+  return locale === 'nl'
+    ? `${n(state.published)} documenten uit · ${n(state.clean)} schoon`
+    : `${n(state.published)} documents out · ${n(state.clean)} clean`;
+}

package/src/components/index.js

@@ -65,6 +65,8 @@ export {default as DeadlineDefender} from './DeadlineDefender/DeadlineDefender.j
 export {default as BlueprintRush} from './BlueprintRush/BlueprintRush.jsx';
 export {default as RecordRun} from './RecordRun/RecordRun.jsx';
 export {default as LockPick} from './LockPick/LockPick.jsx';
+export {default as PaintByTokens} from './PaintByTokens/PaintByTokens.jsx';
+export {default as Redaction} from './Redaction/Redaction.jsx';
 
 /* Diagram-set web-component React wrappers (cn-hex, cn-platform,
    cn-domain-tree, cn-pipeline, cn-side-box, cn-honeycomb-bg, cn-pair,