@datagrok/proteomics 1.0.1 → 1.2.0

package/src/tests/publish-spike.ts

@@ -0,0 +1,377 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+import {awaitCheck, category, delay, test} from '@datagrok-libraries/test/src/test';
+import {SEMTYPE} from '../utils/proteomics-types';
+
+const SPIKE_TAG_KEYS = [
+  'proteomics.source',
+  'proteomics.de_method',
+  'proteomics.de_complete',
+  'proteomics.groups',
+  'proteomics.published',
+  'proteomics.published_at',
+  'proteomics.published_by',
+  'proteomics.published_target',
+  'proteomics.published_de_method',
+  'proteomics.published_fc_threshold',
+  'proteomics.published_p_threshold',
+  'proteomics.published_version',
+  'proteomics.published_id',
+  'proteomics.published_includes_enrichment',
+] as const;
+
+const SPIKE_SEMTYPE_COLS: Array<[string, string]> = [
+  ['Protein ID', SEMTYPE.PROTEIN_ID],
+  ['Gene Name', SEMTYPE.GENE_SYMBOL],
+  ['log2FC', SEMTYPE.LOG2FC],
+  ['adj.p-value', SEMTYPE.P_VALUE],
+];
+
+function emit(label: string, value: unknown): void {
+  let serialized: string;
+  try {
+    serialized = typeof value === 'string' ? value : JSON.stringify(value);
+  } catch {
+    serialized = String(value);
+  }
+  const line = `[publish-spike] ${label}: ${serialized}`;
+  console.log(line);
+  grok.shell.info(line);
+}
+
+function buildFixtureDataFrame(publishedId: string, nowIso: string): DG.DataFrame {
+  const proteinIds = Array.from({length: 10}, (_, i) => `P${String(i + 1).padStart(5, '0')}`);
+  const geneNames = Array.from({length: 10}, (_, i) => `GENE${i + 1}`);
+  const log2fc = new Float32Array([3.0, 2.5, 2.0, 1.5, 0.5, -0.4, -1.6, -2.2, -2.8, 0.1]);
+  const pVals = new Float32Array([0.0001, 0.001, 0.005, 0.02, 0.04, 0.1, 0.001, 0.0005, 0.0001, 0.3]);
+  const adjP = new Float32Array([0.001, 0.005, 0.01, 0.04, 0.08, 0.2, 0.005, 0.001, 0.0005, 0.5]);
+  const significant = ['up', 'up', 'up', 'up', 'ns', 'ns', 'down', 'down', 'down', 'ns'];
+  const direction = ['Enriched in Treatment', 'Enriched in Treatment', 'Enriched in Treatment',
+    'Enriched in Treatment', 'Not significant', 'Not significant',
+    'Enriched in Control', 'Enriched in Control', 'Enriched in Control', 'Not significant'];
+
+  const df = DG.DataFrame.fromColumns([
+    DG.Column.fromStrings('Protein ID', proteinIds),
+    DG.Column.fromStrings('Gene Name', geneNames),
+    DG.Column.fromFloat32Array('log2FC', log2fc),
+    DG.Column.fromFloat32Array('p-value', pVals),
+    DG.Column.fromFloat32Array('adj.p-value', adjP),
+    DG.Column.fromStrings('significant', significant),
+    DG.Column.fromStrings('direction', direction),
+  ]);
+
+  for (const [colName, sem] of SPIKE_SEMTYPE_COLS)
+    df.col(colName)!.semType = sem;
+
+  df.name = 'spike-source';
+
+  const groupsPayload = {
+    group1: {name: 'Control', columns: []},
+    group2: {name: 'Treatment', columns: []},
+  };
+
+  const tagValues: Record<string, string> = {
+    'proteomics.source': 'generic',
+    'proteomics.de_method': 'limma',
+    'proteomics.de_complete': 'true',
+    'proteomics.groups': JSON.stringify(groupsPayload),
+    'proteomics.published': 'true',
+    'proteomics.published_at': nowIso,
+    'proteomics.published_by': 'spike-operator',
+    'proteomics.published_target': 'SPIKE-TARGET-A',
+    'proteomics.published_de_method': 'limma',
+    'proteomics.published_fc_threshold': '1.0',
+    'proteomics.published_p_threshold': '0.05',
+    'proteomics.published_version': '1',
+    'proteomics.published_id': publishedId,
+    'proteomics.published_includes_enrichment': 'false',
+  };
+
+  for (const [k, v] of Object.entries(tagValues))
+    df.setTag(k, v);
+
+  return df;
+}
+
+function summarizeViewers(): Array<Record<string, unknown>> {
+  const out: Array<Record<string, unknown>> = [];
+  const tv = grok.shell.tv;
+  if (!tv) return out;
+  for (const v of tv.viewers) {
+    let props: any = null;
+    try {
+      props = (v as any).getOptions ? (v as any).getOptions()?.look ?? (v as any).getOptions() : null;
+    } catch (e) {
+      props = `getOptions-threw:${(e as Error)?.message ?? e}`;
+    }
+    let xCol: unknown;
+    let yCol: unknown;
+    let colorCol: unknown;
+    try { xCol = (v as any).props?.xColumnName; } catch { /* swallow */ }
+    try { yCol = (v as any).props?.yColumnName; } catch { /* swallow */ }
+    try { colorCol = (v as any).props?.colorColumnName; } catch { /* swallow */ }
+    out.push({
+      type: v.type,
+      xColumnName: xCol,
+      yColumnName: yCol,
+      colorColumnName: colorCol,
+      props,
+    });
+  }
+  return out;
+}
+
+async function safeDelete(label: string, fn: () => Promise<void>): Promise<void> {
+  try {
+    await fn();
+    emit(`cleanup:${label}`, 'ok');
+  } catch (e) {
+    emit(`cleanup:${label}:error`, `${(e as Error)?.message ?? e}`);
+  }
+}
+
+category('Publishing-Spike', () => {
+  test('save+open roundtrip — enumerate survivors', async () => {
+    const ts = Date.now();
+    const publishedId = `spike-pub-${ts}`;
+    const nowIso = new Date(ts).toISOString();
+    const projectName = `spike-publish-roundtrip-${ts}`;
+
+    emit('boot', {projectName, publishedId, nowIso});
+
+    // (1) Build the fixture DataFrame and prime tags + semTypes.
+    const df = buildFixtureDataFrame(publishedId, nowIso);
+
+    // (2) Open in a TableView and add a scatter plot mimicking the volcano shape.
+    const tv = grok.shell.addTableView(df);
+    await delay(100);
+    let sp: DG.ScatterPlotViewer | null = null;
+    try {
+      const tvAny = tv as any;
+      if (typeof tvAny.scatterPlot === 'function') {
+        sp = tvAny.scatterPlot({x: 'log2FC', y: 'adj.p-value'});
+      } else {
+        sp = DG.Viewer.scatterPlot(df, {x: 'log2FC', y: 'adj.p-value'});
+        let already = false;
+        try { already = Array.from(tv.viewers).includes(sp as any); } catch { /* ignore */ }
+        if (sp && !already) tv.addViewer(sp as DG.Viewer);
+      }
+    } catch (e) {
+      emit('scatter-add-error', `${(e as Error)?.message ?? e}`);
+    }
+    await delay(100);
+
+    // (3) Create Project, set TWO options entries (A4 probe), attach children.
+    const project = DG.Project.create();
+    project.name = projectName;
+    try {
+      (project as any).options['proteomics.superseded_by'] = 'dummy-id-A';
+      (project as any).options['custom_option'] = 'hello';
+    } catch (e) {
+      emit('project-options-set-error', `${(e as Error)?.message ?? e}`);
+    }
+
+    const tableInfo = tv.dataFrame.getTableInfo();
+    const layoutInfo = tv.getInfo();
+    project.addChild(tableInfo);
+    project.addChild(layoutInfo);
+
+    let tableInfoId: string | null = null;
+    let projectId: string | null = null;
+    let savedSuccessfully = false;
+    try {
+      await grok.dapi.tables.uploadDataFrame(tv.dataFrame);
+      await grok.dapi.tables.save(tableInfo);
+      tableInfoId = tableInfo.id;
+      await grok.dapi.views.save(layoutInfo);
+      await grok.dapi.projects.save(project);
+      projectId = project.id;
+      savedSuccessfully = true;
+      emit('save:ok', {projectId, tableInfoId});
+    } catch (e) {
+      emit('save:error', `${(e as Error)?.message ?? e}`);
+    }
+
+    if (!savedSuccessfully || !projectId) {
+      emit('halt', 'save sequence failed — skipping reopen and downstream probes');
+      try { grok.shell.closeAll(); } catch { /* noop */ }
+      return;
+    }
+
+    // (4) Capture id, close shell, find + open.
+    try { grok.shell.closeAll(); } catch (e) { emit('closeAll-error', `${(e as Error)?.message ?? e}`); }
+    await delay(100);
+
+    let reopenedProject: DG.Project | null = null;
+    try {
+      reopenedProject = await grok.dapi.projects.find(projectId);
+      await reopenedProject.open();
+    } catch (e) {
+      emit('reopen:error', `${(e as Error)?.message ?? e}`);
+    }
+    if (!reopenedProject) {
+      emit('halt', 'reopen failed — skipping enumeration');
+      return;
+    }
+
+    try {
+      await awaitCheck(
+        () => !!grok.shell.tv && !!grok.shell.tv.dataFrame,
+        'TableView did not materialize after Project.open()',
+        5000,
+      );
+    } catch (e) {
+      emit('await-tv-error', `${(e as Error)?.message ?? e}`);
+    }
+
+    // (5) Enumerate survivors.
+    const reTv = grok.shell.tv;
+    const reDf = reTv?.dataFrame ?? null;
+
+    emit('df.name survived', reDf?.name ?? '(no dataFrame)');
+
+    if (reDf) {
+      const tagSurvival: Record<string, string | null> = {};
+      for (const k of SPIKE_TAG_KEYS)
+        tagSurvival[k] = reDf.getTag(k) ?? null;
+      emit('proteomics.* tags survived', tagSurvival);
+
+      const semTypeSurvival: Record<string, string | null> = {};
+      for (const [colName] of SPIKE_SEMTYPE_COLS) {
+        const c = reDf.col(colName);
+        semTypeSurvival[colName] = c ? (c.semType ?? null) : '(column missing)';
+      }
+      emit('Proteomics-* semTypes survived', semTypeSurvival);
+
+      const allCols = reDf.columns.toList().map((c) => ({name: c.name, type: c.type, semType: c.semType ?? null}));
+      emit('reopened columns shape', allCols);
+    }
+
+    // project.options enumeration (A4)
+    try {
+      const opts = (reopenedProject as any).options ?? {};
+      const o1 = opts['proteomics.superseded_by'];
+      const o2 = opts['custom_option'];
+      let optsKeys: string[] = [];
+      try { optsKeys = Object.keys(opts); } catch { /* swallow */ }
+      emit('project.options', {
+        'proteomics.superseded_by': o1 ?? null,
+        'custom_option': o2 ?? null,
+        keys: optsKeys,
+        rawJson: (() => { try { return JSON.stringify(opts); } catch { return '(unstringifiable)'; } })(),
+      });
+    } catch (e) {
+      emit('project.options:error', `${(e as Error)?.message ?? e}`);
+    }
+
+    // Viewer survival + bindings (A6)
+    emit('viewers after reopen', summarizeViewers());
+
+    // permissions.get shape (A1)
+    try {
+      const perm: any = await grok.dapi.permissions.get(reopenedProject);
+      let keys: string[] = [];
+      try { keys = Object.keys(perm); } catch { /* swallow */ }
+      let permJson = '(unstringifiable)';
+      try { permJson = JSON.stringify(perm); } catch { /* swallow */ }
+      emit('permissions.get keys', keys);
+      emit('permissions.get json', permJson);
+    } catch (e) {
+      emit('permissions.get:error', `${(e as Error)?.message ?? e}`);
+    }
+
+    // (6) Space-inheritance probe (A2).
+    let umbrellaSpace: any = null;
+    let inheritedChildSpace: any = null;
+    try {
+      umbrellaSpace = await (grok.dapi as any).spaces.createRootSpace(`Spike-Reviews-${ts}`);
+      emit('umbrella-space', {id: umbrellaSpace.id, friendlyName: (umbrellaSpace as any).friendlyName});
+      const umbrellaClient = (grok.dapi as any).spaces.id(umbrellaSpace.id);
+      inheritedChildSpace = await umbrellaClient.addSubspace(`Spike-Review-Inherit-${ts}`);
+      emit('inherited-child-space', {id: inheritedChildSpace.id, friendlyName: (inheritedChildSpace as any).friendlyName});
+      const inheritedClient = (grok.dapi as any).spaces.id(inheritedChildSpace.id);
+      try {
+        await inheritedClient.addEntity(reopenedProject.id);
+        emit('inherited-child:addEntity', 'ok');
+      } catch (e) {
+        emit('inherited-child:addEntity:error', `${(e as Error)?.message ?? e}`);
+      }
+      try {
+        const me = await grok.dapi.users.current();
+        const myGroup: any = (me as any).group ?? null;
+        if (myGroup) {
+          await grok.dapi.permissions.grant(umbrellaSpace, myGroup, false);
+          emit('umbrella-space:grant-view', {group: (myGroup as any).friendlyName ?? (myGroup as any).name ?? '(unnamed)'});
+        } else {
+          emit('umbrella-space:grant-skipped', 'no user.group found');
+        }
+      } catch (e) {
+        emit('umbrella-space:grant:error', `${(e as Error)?.message ?? e}`);
+      }
+      try {
+        const childPerm = await grok.dapi.permissions.get(reopenedProject);
+        let cpKeys: string[] = [];
+        try { cpKeys = Object.keys(childPerm as any); } catch { /* swallow */ }
+        emit('permissions.get(childProject) after umbrella-grant', {
+          keys: cpKeys,
+          json: (() => { try { return JSON.stringify(childPerm); } catch { return '(unstringifiable)'; } })(),
+        });
+      } catch (e) {
+        emit('childProject:permissions.get:error', `${(e as Error)?.message ?? e}`);
+      }
+    } catch (e) {
+      emit('space-probe:error', `${(e as Error)?.message ?? e}`);
+    }
+
+    // (7) Smart-filter syntax probe (A8).
+    try {
+      const likeList: any = await grok.dapi.projects.filter('name like "spike-publish-roundtrip-%"').list();
+      emit('filter "like" result', {count: Array.isArray(likeList) ? likeList.length : '(non-array)',
+        firstName: Array.isArray(likeList) && likeList.length > 0 ? (likeList[0] as any).name ?? null : null});
+    } catch (e) {
+      emit('filter:like:error', `${(e as Error)?.message ?? e}`);
+    }
+    try {
+      const containsList: any = await grok.dapi.projects.filter('name contains "spike-publish-roundtrip"').list();
+      emit('filter "contains" result', {count: Array.isArray(containsList) ? containsList.length : '(non-array)',
+        firstName: Array.isArray(containsList) && containsList.length > 0 ? (containsList[0] as any).name ?? null : null});
+    } catch (e) {
+      emit('filter:contains:error', `${(e as Error)?.message ?? e}`);
+    }
+
+    // (8) Delete-cascade probe (A3).
+    const savedTableInfoId = tableInfoId;
+    try {
+      await grok.dapi.projects.delete(reopenedProject);
+      emit('projects.delete', 'ok');
+    } catch (e) {
+      emit('projects.delete:error', `${(e as Error)?.message ?? e}`);
+    }
+    if (savedTableInfoId) {
+      try {
+        const t = await grok.dapi.tables.find(savedTableInfoId);
+        emit('tables.find(tableInfoId) after project.delete', {
+          resolved: !!t,
+          name: t ? (t as any).name ?? null : null,
+        });
+      } catch (e) {
+        emit('tables.find:after-delete:error', `${(e as Error)?.message ?? e}`);
+      }
+    }
+
+    // (9) Cleanup — idempotent.
+    if (inheritedChildSpace)
+      await safeDelete('inherited-child-space', () => (grok.dapi as any).spaces.delete(inheritedChildSpace));
+    if (umbrellaSpace)
+      await safeDelete('umbrella-space', () => (grok.dapi as any).spaces.delete(umbrellaSpace));
+    // Best-effort: delete the project again in case the A3 probe earlier already ran but didn't cascade.
+    await safeDelete('project (idempotent)', async () => {
+      try {
+        const stillThere = await grok.dapi.projects.find(projectId!);
+        if (stillThere) await grok.dapi.projects.delete(stillThere);
+      } catch { /* not found is fine */ }
+    });
+
+    emit('done', 'spike enumeration complete — read output above');
+  });
+});

package/src/tests/qc-dashboard.ts

@@ -0,0 +1,210 @@
+import * as DG from 'datagrok-api/dg';
+import {category, test, expect} from '@datagrok-libraries/test/src/test';
+import {
+  computeMA,
+  computeCV,
+  computeLoessTrend,
+  createMissingnessMatrix,
+  unpivotIntensities,
+  computeMissingBarData,
+  getIntensityColumns,
+} from '../viewers/qc-computations';
+import {GroupAssignment} from '../analysis/experiment-setup';
+import {SEMTYPE} from '../utils/proteomics-types';
+
+category('QC Dashboard', () => {
+  test('getIntensityColumns', async () => {
+    const col1 = DG.Column.fromFloat32Array('log2(sample1)', new Float32Array([1, 2]));
+    col1.semType = SEMTYPE.INTENSITY;
+    const col2 = DG.Column.fromFloat32Array('other', new Float32Array([3, 4]));
+    const col3 = DG.Column.fromFloat32Array('log2(sample2)', new Float32Array([5, 6]));
+    col3.semType = SEMTYPE.INTENSITY;
+    const df = DG.DataFrame.fromColumns([col1, col2, col3]);
+
+    const result = getIntensityColumns(df);
+    expect(result.length, 2);
+    expect(result[0], 'log2(sample1)');
+    expect(result[1], 'log2(sample2)');
+  });
+
+  test('MA computation', async () => {
+    // 3 rows, 4 intensity columns: 2 per group
+    const c1 = DG.Column.fromFloat32Array('log2(ctrl1)', new Float32Array([10, 5, 8]));
+    c1.semType = SEMTYPE.INTENSITY;
+    const c2 = DG.Column.fromFloat32Array('log2(ctrl2)', new Float32Array([12, 7, 6]));
+    c2.semType = SEMTYPE.INTENSITY;
+    const c3 = DG.Column.fromFloat32Array('log2(treat1)', new Float32Array([8, 3, DG.FLOAT_NULL]));
+    c3.semType = SEMTYPE.INTENSITY;
+    const c4 = DG.Column.fromFloat32Array('log2(treat2)', new Float32Array([6, 5, DG.FLOAT_NULL]));
+    c4.semType = SEMTYPE.INTENSITY;
+
+    const df = DG.DataFrame.fromColumns([c1, c2, c3, c4]);
+    const groups: GroupAssignment = {
+      group1: {name: 'Control', columns: ['log2(ctrl1)', 'log2(ctrl2)']},
+      group2: {name: 'Treatment', columns: ['log2(treat1)', 'log2(treat2)']},
+    };
+
+    computeMA(df, groups);
+
+    const mCol = df.col('M')!;
+    const aCol = df.col('A')!;
+
+    // Row 0: g1Mean = (10+12)/2 = 11, g2Mean = (8+6)/2 = 7
+    // M = g2 - g1 = 7 - 11 = -4, A = (11+7)/2 = 9
+    expect(Math.abs(mCol.get(0) - (-4)) < 0.01, true);
+    expect(Math.abs(aCol.get(0) - 9) < 0.01, true);
+
+    // Row 2: all null in group2 -> M and A should be null
+    expect(mCol.isNone(2), true);
+    expect(aCol.isNone(2), true);
+  });
+
+  test('CV computation', async () => {
+    // 2 rows, 3 columns for one group
+    // Row 0: all identical values (2, 2, 2) -> CV = 0
+    // Row 1: varied values -> CV > 0
+    const c1 = DG.Column.fromFloat32Array('log2(s1)', new Float32Array([2, 3]));
+    c1.semType = SEMTYPE.INTENSITY;
+    const c2 = DG.Column.fromFloat32Array('log2(s2)', new Float32Array([2, 5]));
+    c2.semType = SEMTYPE.INTENSITY;
+    const c3 = DG.Column.fromFloat32Array('log2(s3)', new Float32Array([2, 7]));
+    c3.semType = SEMTYPE.INTENSITY;
+
+    const df = DG.DataFrame.fromColumns([c1, c2, c3]);
+    computeCV(df, ['log2(s1)', 'log2(s2)', 'log2(s3)'], 'CV', 'Mean');
+
+    const cvCol = df.col('CV')!;
+    const meanCol = df.col('Mean')!;
+
+    // Row 0: all log2 values = 2, raw = 2^2 = 4 for all. sd = 0, CV = 0. Mean = 4.
+    expect(Math.abs(cvCol.get(0)) < 0.001, true);
+    expect(Math.abs(meanCol.get(0) - 4) < 0.01, true);
+
+    // Row 1: varied values -> CV > 0
+    expect(cvCol.get(1) > 0, true);
+  });
+
+  test('Loess/moving-average trend', async () => {
+    // Create a DataFrame with M and A columns, 20+ rows
+    const n = 25;
+    // Use a seeded LCG instead of Math.random so the smoothness assertion
+    // below isn't flaky on adversarial RNG draws.
+    let seed = 12345;
+    const rand = () => {
+      seed = (seed * 1664525 + 1013904223) >>> 0;
+      return seed / 0xFFFFFFFF;
+    };
+    const aValues = new Float32Array(n);
+    const mValues = new Float32Array(n);
+    for (let i = 0; i < n; i++) {
+      aValues[i] = i + 1; // A from 1 to 25
+      mValues[i] = 0.5 * Math.sin(i / 5) + (rand() - 0.5) * 0.3; // pattern + seeded noise
+    }
+
+    const df = DG.DataFrame.fromColumns([
+      DG.Column.fromFloat32Array('A', aValues),
+      DG.Column.fromFloat32Array('M', mValues),
+    ]);
+
+    computeLoessTrend(df, 0.5);
+
+    // Assert MA_trend column exists
+    const trendCol = df.col('MA_trend');
+    expect(trendCol !== null, true);
+
+    // Assert not all null
+    let nonNullCount = 0;
+    for (let i = 0; i < n; i++) {
+      if (!trendCol!.isNone(i))
+        nonNullCount++;
+    }
+    expect(nonNullCount > 0, true);
+
+    // Assert trend is smoother than raw M: variance(trend) < variance(M)
+    let sumM = 0; let sumM2 = 0; let countM = 0;
+    let sumT = 0; let sumT2 = 0; let countT = 0;
+    for (let i = 0; i < n; i++) {
+      const m = mValues[i];
+      sumM += m; sumM2 += m * m; countM++;
+      if (!trendCol!.isNone(i)) {
+        const t = trendCol!.get(i) as number;
+        sumT += t; sumT2 += t * t; countT++;
+      }
+    }
+    const varM = (sumM2 / countM) - (sumM / countM) * (sumM / countM);
+    const varT = (sumT2 / countT) - (sumT / countT) * (sumT / countT);
+    expect(varT < varM, true);
+  });
+
+  test('Missingness matrix', async () => {
+    const c1 = DG.Column.fromFloat32Array('log2(s1)', new Float32Array([5.0, DG.FLOAT_NULL]));
+    c1.semType = SEMTYPE.INTENSITY;
+    const c2 = DG.Column.fromFloat32Array('log2(s2)', new Float32Array([DG.FLOAT_NULL, 3.0]));
+    c2.semType = SEMTYPE.INTENSITY;
+
+    const df = DG.DataFrame.fromColumns([c1, c2]);
+    const result = createMissingnessMatrix(df, ['log2(s1)', 'log2(s2)']);
+
+    expect(result.rowCount, 2);
+    expect(result.name, 'Missing Values');
+
+    // Row 0: s1=present(1), s2=missing(0)
+    const rc1 = result.col('log2(s1)')!;
+    const rc2 = result.col('log2(s2)')!;
+    expect(rc1.get(0), 1);
+    expect(rc2.get(0), 0);
+    // Row 1: s1=missing(0), s2=present(1)
+    expect(rc1.get(1), 0);
+    expect(rc2.get(1), 1);
+  });
+
+  test('Unpivot intensities', async () => {
+    const idCol = DG.Column.fromStrings('Protein ID', ['P0', 'P1']);
+    idCol.semType = SEMTYPE.PROTEIN_ID;
+    const c1 = DG.Column.fromFloat32Array('log2(s1)', new Float32Array([10, DG.FLOAT_NULL]));
+    c1.semType = SEMTYPE.INTENSITY;
+    const c2 = DG.Column.fromFloat32Array('log2(s2)', new Float32Array([20, 30]));
+    c2.semType = SEMTYPE.INTENSITY;
+
+    const df = DG.DataFrame.fromColumns([idCol, c1, c2]);
+    const result = unpivotIntensities(df, ['log2(s1)', 'log2(s2)']);
+
+    expect(result.name, 'Intensity Distributions');
+    // 3 non-null values: P0/s1(10), P0/s2(20), P1/s2(30)
+    expect(result.rowCount, 3);
+    expect(result.col('ProteinId') !== null, true);
+    expect(result.col('Sample') !== null, true);
+    expect(result.col('Intensity') !== null, true);
+  });
+
+  test('Missing bar data', async () => {
+    // 3 rows, 2 intensity columns (1 per group)
+    // Col 0: 1 null out of 3 (33.3%)
+    // Col 1: 0 null out of 3 (0%)
+    const c1 = DG.Column.fromFloat32Array('log2(ctrl1)', new Float32Array([5, DG.FLOAT_NULL, 7]));
+    c1.semType = SEMTYPE.INTENSITY;
+    const c2 = DG.Column.fromFloat32Array('log2(treat1)', new Float32Array([10, 11, 12]));
+    c2.semType = SEMTYPE.INTENSITY;
+
+    const df = DG.DataFrame.fromColumns([c1, c2]);
+    const groups: GroupAssignment = {
+      group1: {name: 'Control', columns: ['log2(ctrl1)']},
+      group2: {name: 'Treatment', columns: ['log2(treat1)']},
+    };
+
+    const result = computeMissingBarData(df, ['log2(ctrl1)', 'log2(treat1)'], groups);
+
+    expect(result.rowCount, 2);
+    const pctCol = result.col('MissingPct')!;
+    const grpCol = result.col('Group')!;
+
+    // Row 0 (ctrl1): ~33.3% missing
+    expect(Math.abs(pctCol.get(0) - 33.333) < 1, true);
+    // Row 1 (treat1): 0% missing
+    expect(Math.abs(pctCol.get(1)) < 0.01, true);
+
+    // Group assignments
+    expect(grpCol.get(0), 'Control');
+    expect(grpCol.get(1), 'Treatment');
+  });
+});