@_linked/shape-ui 2.0.0 → 2.3.0

package/src/read.ts

@@ -0,0 +1,148 @@
+/**
+ * Reading instances of a shape, through the Linked Query DSL.
+ *
+ * The counterpart of `write.ts`, and the piece a consumer previously had to write themselves:
+ * the components took `instances` as a prop, and the only exported read helper was
+ * picker-shaped (label only). So a host got the rendering for free and reimplemented the
+ * reading — which is how two ideas of "what a row is" appear in one codebase.
+ *
+ * Names no project. `SelectBuilder.from(shapeIri)` is routed by `LinkedStorage` exactly as the
+ * write is: `AppDataRouter` inside a studio, the app's own default dataset in a standalone or
+ * Capacitor build. Read and write route as a pair, or a table ends up looking at a different
+ * dataset than the form saves into.
+ *
+ * The projection comes from `columnsFor`, the same rule the table's columns use, so a row can
+ * never carry a property the table does not show or miss one it does.
+ */
+
+import {SelectBuilder} from '@_linked/core/queries/QueryBuilder';
+import type {
+  NodeShapeWire,
+  PropertyShapeWire,
+} from '@_linked/core/shapes/nodeShapeWire';
+import {columnsFor, type DisplayContext} from './columns.js';
+
+/**
+ * Key each row by the property LABEL, whatever the query returned.
+ *
+ * The projection asks for `instance[property.label]`, but results come back keyed by the
+ * property-shape IRI's local part. For the framework's own IRI scheme —
+ * `.../shape/{pkg}/{Shape}/{prop}` — those are the same string, so the mismatch is invisible.
+ * For a shape authored in a hash namespace they are not: `…/vocab#Contact/name` has the local
+ * part `Contact/name`, and every value lands under a key no caller looks up. The table then
+ * renders empty columns with no error, which is the worst way for this to fail.
+ *
+ * Matching on the last path segment is what makes both schemes agree. Anything already keyed
+ * by its label is left alone, so this costs nothing in the common case.
+ */
+function keyByLabel(
+  rows: Record<string, unknown>[],
+  properties: PropertyShapeWire[],
+): Record<string, unknown>[] {
+  const labels = properties.map((p) => p.label).filter(Boolean) as string[];
+  if (labels.length === 0) return rows;
+
+  const lastSegment = (key: string) => key.split(/[#/]/).pop() ?? key;
+
+  return rows.map((row) => {
+    const out: Record<string, unknown> = {};
+    // `id` is not a property; it names the row.
+    if ('id' in row) out.id = row.id;
+    for (const label of labels) {
+      if (label in row) {
+        out[label] = row[label];
+        continue;
+      }
+      const match = Object.keys(row).find(
+        (key) => key !== 'id' && lastSegment(key) === label,
+      );
+      if (match) out[label] = row[match];
+    }
+    return out;
+  });
+}
+
+export interface InstanceQuery {
+  /** Which properties to read. Defaults to the columns for `context`. */
+  properties?: PropertyShapeWire[];
+  context?: DisplayContext;
+  limit?: number;
+  offset?: number;
+}
+
+export interface InstanceRows {
+  rows: Record<string, unknown>[];
+  /** The properties actually read, in the order they were asked for. */
+  properties: PropertyShapeWire[];
+}
+
+/**
+ * Instances of one shape.
+ *
+ * The shape must already be registered — call `loadShapeCatalog` first. That is deliberate
+ * rather than convenient: registering inside the query would hide a catalog read behind
+ * every table refresh.
+ */
+export async function selectInstances(
+  shape: NodeShapeWire,
+  query: InstanceQuery = {},
+): Promise<InstanceRows> {
+  const properties =
+    query.properties ??
+    columnsFor(shape, query.context ?? 'table').map((column) => column.property);
+
+  if (properties.length === 0) {
+    // Nothing showable. An empty result is the honest answer; a query with no projection
+    // would either error or return bare subjects the caller cannot render.
+    return {rows: [], properties};
+  }
+
+  // `any` on the proxy parameter is the established form for a runtime shape: the shape
+  // is not a compiled class, so there is no generated type for the builder to infer from.
+  // The property labels are the contract, and they come from the shape itself.
+  let builder = SelectBuilder.from(shape.id).select((instance: any) =>
+    properties.map((property) => instance[property.label]),
+  ) as unknown as {
+    limit(n: number): unknown;
+    offset(n: number): unknown;
+    exec(): Promise<Record<string, unknown>[]>;
+  };
+
+  if (query.limit != null) builder = builder.limit(query.limit) as typeof builder;
+  if (query.offset != null) builder = builder.offset(query.offset) as typeof builder;
+
+  const rows = await builder.exec();
+  return {rows: keyByLabel(rows ?? [], properties), properties};
+}
+
+/**
+ * One instance by id.
+ *
+ * Same query as {@link selectInstances}, narrowed to a subject — so a detail view and a
+ * table cannot disagree about what a property means or how it is read.
+ */
+export async function selectInstance(
+  shape: NodeShapeWire,
+  instanceId: string,
+  query: InstanceQuery = {},
+): Promise<{row: Record<string, unknown> | null; properties: PropertyShapeWire[]}> {
+  const properties =
+    query.properties ??
+    (shape.propertyShapes ?? []).filter((p) => p.displayHidden !== true && !!p.label);
+
+  if (properties.length === 0) return {row: null, properties};
+
+  const rows = (await (
+    SelectBuilder.from(shape.id).select((instance: any) =>
+      properties.map((property) => instance[property.label]),
+    ) as unknown as {
+      where(fn: (i: any) => unknown): {
+        exec(): Promise<Record<string, unknown>[]>;
+      };
+    }
+  )
+    .where((instance: any) => instance.equals({id: instanceId}))
+    .exec()) as Record<string, unknown>[];
+
+  return {row: keyByLabel(rows ?? [], properties)[0] ?? null, properties};
+}

package/src/search.test.ts

@@ -0,0 +1,174 @@
+import {beforeEach, describe, expect, jest, test} from '@jest/globals';
+import type {NodeShapeWire} from '@_linked/core/shapes/nodeShapeWire';
+
+/**
+ * The DSL default for relation-field search.
+ *
+ * Two things are worth pinning: it names **no project** (that is the portability claim),
+ * and it derives the label from `labelProperty()` — the same rule the table uses, so a row
+ * and a picker chip cannot disagree about what identifies an instance.
+ *
+ * The builder is mocked; what matters is the shape of the call, not the SPARQL, which
+ * core's own suite covers.
+ */
+
+const fromMock = jest.fn();
+const selectMock = jest.fn();
+const whereMock = jest.fn();
+const limitMock = jest.fn();
+const offsetMock = jest.fn();
+const execMock = jest.fn<() => Promise<Record<string, unknown>[]>>();
+
+jest.unstable_mockModule('@_linked/core/queries/QueryBuilder', () => ({
+  SelectBuilder: {
+    from: (...args: unknown[]) => {
+      fromMock(...args);
+      const builder: Record<string, unknown> = {};
+      builder.select = (fn: (i: Record<string, unknown>) => unknown) => {
+        const read: string[] = [];
+        fn(new Proxy({}, {get: (_t, key) => (read.push(String(key)), key)}));
+        selectMock(read);
+        return builder;
+      };
+      builder.where = (fn: (i: unknown) => unknown) => {
+        fn(
+          new Proxy(
+            {},
+            {
+              get: () => ({
+                contains: (v: unknown) => (whereMock(v), true),
+              }),
+            },
+          ),
+        );
+        return builder;
+      };
+      builder.limit = (n: number) => (limitMock(n), builder);
+      builder.offset = (n: number) => (offsetMock(n), builder);
+      builder.exec = execMock;
+      return builder;
+    },
+  },
+}));
+
+const {searchInstancesWithDsl, narrowSuggestions} = await import('./search.js');
+
+const base = 'https://example.org/';
+
+const shape = (props: Record<string, unknown>[]): NodeShapeWire =>
+  ({
+    id: `${base}shape/Person`,
+    label: 'Person',
+    targetClass: {id: `${base}vocab#Person`},
+    propertyShapes: props,
+  }) as NodeShapeWire;
+
+const prop = (label: string, extra: Record<string, unknown> = {}) => ({
+  id: `${base}shape/Person/${label}`,
+  label,
+  path: {id: `${base}vocab#${label}`},
+  ...extra,
+});
+
+const rows = (n: number, labelKey = 'name') =>
+  Array.from({length: n}, (_, i) => ({id: `urn:${i}`, [labelKey]: `Person ${i}`}));
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  execMock.mockResolvedValue(rows(3));
+});
+
+describe('searchInstancesWithDsl', () => {
+  test('queries by shape IRI and names no project', async () => {
+    await searchInstancesWithDsl(shape([prop('name')]));
+    expect(fromMock).toHaveBeenCalledWith(`${base}shape/Person`);
+    expect(fromMock.mock.calls[0]).toHaveLength(1);
+  });
+
+  test('projects the label property the table would use', async () => {
+    await searchInstancesWithDsl(
+      shape([prop('sku'), prop('name', {displayRank: 1})]),
+    );
+    expect(selectMock).toHaveBeenCalledWith(['name']);
+  });
+
+  test('a text query filters on the label', async () => {
+    await searchInstancesWithDsl(shape([prop('name')]), {query: 'ada'});
+    expect(whereMock).toHaveBeenCalledWith('ada');
+  });
+
+  test('an empty or whitespace query browses rather than filtering', async () => {
+    await searchInstancesWithDsl(shape([prop('name')]), {query: '   '});
+    expect(whereMock).not.toHaveBeenCalled();
+  });
+
+  test('asks for one more than the page, to answer hasMore without a COUNT', async () => {
+    execMock.mockResolvedValue(rows(21));
+    const result = await searchInstancesWithDsl(shape([prop('name')]), {limit: 20});
+    expect(limitMock).toHaveBeenCalledWith(21);
+    expect(result.results).toHaveLength(20);
+    expect(result.hasMore).toBe(true);
+  });
+
+  test('hasMore is false when the probe comes back short', async () => {
+    execMock.mockResolvedValue(rows(5));
+    const result = await searchInstancesWithDsl(shape([prop('name')]), {limit: 20});
+    expect(result.hasMore).toBe(false);
+    expect(result.results).toHaveLength(5);
+  });
+
+  test('offset is passed only when non-zero', async () => {
+    await searchInstancesWithDsl(shape([prop('name')]), {offset: 0});
+    expect(offsetMock).not.toHaveBeenCalled();
+    await searchInstancesWithDsl(shape([prop('name')]), {offset: 40});
+    expect(offsetMock).toHaveBeenCalledWith(40);
+  });
+
+  test('falls back to the IRI when a shape has no showable label', async () => {
+    // A modelling gap, not a crash: showing the id at least lets someone recognise the row.
+    execMock.mockResolvedValue([{id: 'urn:7'}]);
+    const result = await searchInstancesWithDsl(
+      shape([prop('author', {valueShape: {id: `${base}shape/Person`}})]),
+    );
+    expect(result.results[0]).toEqual({id: 'urn:7', label: 'urn:7'});
+  });
+
+  test('a text query on a shape with no label does not filter everything out', async () => {
+    execMock.mockResolvedValue([{id: 'urn:7'}]);
+    const result = await searchInstancesWithDsl(
+      shape([prop('author', {valueShape: {id: `${base}shape/Person`}})]),
+      {query: 'ada'},
+    );
+    expect(whereMock).not.toHaveBeenCalled();
+    expect(result.results).toHaveLength(1);
+  });
+
+  test('reads a label out of a node reference, not just a string', async () => {
+    execMock.mockResolvedValue([{id: 'urn:1', name: {id: 'urn:x', label: 'Ada'}}]);
+    const result = await searchInstancesWithDsl(shape([prop('name')]));
+    expect(result.results[0].label).toBe('Ada');
+  });
+
+  test('survives a query that returns nothing', async () => {
+    execMock.mockResolvedValue(undefined as never);
+    const result = await searchInstancesWithDsl(shape([prop('name')]));
+    expect(result).toEqual({results: [], hasMore: false});
+  });
+});
+
+describe('narrowSuggestions', () => {
+  const suggestions = [
+    {id: 'a', label: 'A'},
+    {id: 'b', label: 'B'},
+  ];
+
+  test('passes everything through when there is no narrowing', () => {
+    expect(narrowSuggestions(suggestions)).toEqual(suggestions);
+    expect(narrowSuggestions(suggestions, [])).toEqual(suggestions);
+    expect(narrowSuggestions(suggestions, null)).toEqual(suggestions);
+  });
+
+  test('keeps only the allowed ids', () => {
+    expect(narrowSuggestions(suggestions, ['b'])).toEqual([{id: 'b', label: 'B'}]);
+  });
+});

package/src/search.ts

@@ -0,0 +1,108 @@
+/**
+ * Searching for instances of a shape, through the Linked Query DSL.
+ *
+ * This is the **default** implementation the host gets for free. Without it,
+ * `searchInstances` was an optional host method, so a relation field rendered an empty
+ * picker until someone wrote a search by hand — which made "works in a standalone app"
+ * true of the table and false of every relation field.
+ *
+ * It names no project. `SelectBuilder.from(shapeIri)` is routed by `LinkedStorage` exactly
+ * like the table read: `AppDataRouter` inside Create Now, the app's own default dataset in
+ * a standalone build.
+ *
+ * The label comes from `labelProperty()` — the same rule the table uses for its label
+ * column, so a row and a picker chip cannot disagree about what identifies an instance.
+ * Create Now's `Project.searchInstances` RPC computed a label server-side with its own
+ * rule; two mechanisms for one question is how the `getShapeInstances` divergence started.
+ */
+
+import {SelectBuilder} from '@_linked/core/queries/QueryBuilder';
+import type {NodeShapeWire} from '@_linked/core/shapes/nodeShapeWire';
+import {labelProperty} from './columns.js';
+import type {InstanceSuggestion, SearchInstancesOptions} from './host.js';
+
+/** Case-insensitive "contains" over the label, or all instances when the query is empty. */
+export async function searchInstancesWithDsl(
+  shape: NodeShapeWire,
+  options: SearchInstancesOptions = {},
+): Promise<{results: InstanceSuggestion[]; hasMore: boolean}> {
+  const label = labelProperty(shape);
+  const limit = options.limit ?? 20;
+  const offset = options.offset ?? 0;
+
+  // Ask for one more than the caller wants. That is how `hasMore` is answered without a
+  // second COUNT query — cheaper, and it cannot disagree with the page it describes.
+  const probe = limit + 1;
+
+  let builder = SelectBuilder.from(shape.id).select((instance: any) =>
+    label ? [instance[label.label]] : [],
+  ) as unknown as {
+    where(fn: (i: any) => unknown): unknown;
+    limit(n: number): unknown;
+    offset(n: number): unknown;
+    exec(): Promise<Record<string, unknown>[]>;
+  };
+
+  const query = options.query?.trim();
+  if (query && label) {
+    // No label means nothing to match on, so a text query would filter everything out —
+    // better to return the unfiltered page than an empty one.
+    builder = builder.where((instance: any) =>
+      instance[label.label].contains(query),
+    ) as typeof builder;
+  }
+
+  builder = builder.limit(probe) as typeof builder;
+  if (offset) builder = builder.offset(offset) as typeof builder;
+
+  const rows = (await builder.exec()) ?? [];
+  const hasMore = rows.length > limit;
+  const page = hasMore ? rows.slice(0, limit) : rows;
+
+  return {
+    results: page.map((row) => toSuggestion(row, label?.label)),
+    hasMore,
+  };
+}
+
+/**
+ * Narrow a result set to specific ids.
+ *
+ * Applied after the query rather than inside it: `narrowedIds` comes from another field's
+ * value and is usually a handful of ids, so filtering in memory avoids building a VALUES
+ * clause for a case that rarely has many members. Revisit if that assumption breaks.
+ */
+export function narrowSuggestions(
+  suggestions: InstanceSuggestion[],
+  narrowedIds?: string[] | null,
+): InstanceSuggestion[] {
+  if (!narrowedIds?.length) return suggestions;
+  const allowed = new Set(narrowedIds);
+  return suggestions.filter((s) => allowed.has(s.id));
+}
+
+function toSuggestion(
+  row: Record<string, unknown>,
+  labelKey?: string,
+): InstanceSuggestion {
+  const id = String(row.id ?? '');
+  const raw = labelKey ? row[labelKey] : undefined;
+  return {
+    id,
+    // Fall back to the IRI rather than an empty chip. A shape with no showable label is a
+    // modelling gap, and showing the id at least lets someone recognise the row.
+    label: displayValue(raw) ?? id,
+  };
+}
+
+function displayValue(value: unknown): string | undefined {
+  if (value == null) return undefined;
+  if (typeof value === 'string') return value || undefined;
+  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
+  if (Array.isArray(value)) return displayValue(value[0]);
+  if (typeof value === 'object') {
+    const candidate = value as {label?: unknown; id?: unknown};
+    return displayValue(candidate.label) ?? displayValue(candidate.id);
+  }
+  return undefined;
+}

package/src/shape/contracts.ts

@@ -0,0 +1,66 @@
+/**
+ * The wire shapes these components speak.
+ *
+ * Declared here rather than imported from a host application's client package. They were
+ * imported from `create-now-js`, and because a `.d.ts` keeps its type imports, the emitted
+ * types carried that dependency forward — so anyone installing this package needed one
+ * product's client just to typecheck a table. That is precisely the coupling the package
+ * exists to avoid, and it survived the move because type-only imports are invisible at
+ * runtime and nothing complained.
+ *
+ * TypeScript is structural, so a host that already has its own version of these — under any
+ * name — passes them straight in with no adapter and no cast.
+ */
+
+import type {PaginationState} from '@tanstack/react-table';
+
+/** Which page of a shape's instances to read, in what order, filtered how. */
+export interface ShapeInstancesQueryConfig extends PaginationState {
+  orderBy?: unknown;
+  filters: unknown[];
+}
+
+/** One instance marked for deletion. */
+export interface InstanceDeletionTarget {
+  instanceId: string;
+  shapeIri: string;
+}
+
+/** Something pointing AT an instance that is about to be deleted. */
+export interface InstanceDeletionInboundReference {
+  subjectId: string;
+  propertyIri: string;
+}
+
+/**
+ * What deleting would actually do.
+ *
+ * `impactHash` is the point of the two-step flow: the host re-checks it before deleting, so a
+ * preview the viewer read and a graph that changed underneath cannot be confirmed by mistake.
+ */
+export interface InstanceDeletionPreview {
+  impactHash: string;
+  targets: Array<
+    InstanceDeletionTarget & {
+      inboundReferences: InstanceDeletionInboundReference[];
+      sourceDocuments: string[];
+      pendingRecreation: boolean;
+    }
+  >;
+}
+
+export interface InstanceDeletionPreviewInput {
+  projectId: string;
+  targets: InstanceDeletionTarget[];
+}
+
+export interface InstanceDeletionExecuteInput extends InstanceDeletionPreviewInput {
+  expectedImpactHash: string;
+}
+
+export interface InstanceDeletionResult {
+  deleted: InstanceDeletionTarget[];
+  /** Not deleted, because a source document would recreate them on the next ingestion. */
+  suppressed: Array<InstanceDeletionTarget & {sourceDocumentIds: string[]}>;
+  activityEventId?: string;
+}

package/src/shape/naming.ts

@@ -0,0 +1,52 @@
+/**
+ * Turning a shape IRI or a label into something a person can read.
+ *
+ * Pure string work over the Linked shape-IRI scheme (arch-02), with no knowledge of any
+ * application: the same IRI produces the same short form wherever it is rendered. These live
+ * here because a table header, a form label and a breadcrumb must not each have their own idea
+ * of how `ActionPlan` is written out.
+ */
+
+/**
+ * Format a shape or property label for display.
+ *
+ * `actionPlan` → `Action Plan`, and `HTMLParser` → `HTML Parser` — the second rule exists
+ * because the naive lowercase-to-uppercase split turns an acronym into `H T M L Parser`.
+ * Already-spaced and lowercase-only strings pass through unharmed.
+ */
+export function formatShapeLabel(str: string): string {
+  if (!str) return str;
+  return str
+    .replace(/([a-z])([A-Z])/g, '$1 $2')
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+    .replace(/^./, (c) => c.toUpperCase())
+    .trim();
+}
+
+/**
+ * The short form of a shape IRI: `{packageSlug}:{ShapeName}`.
+ *
+ * Current scheme (arch-02): `https://linked.cm/shape/{slug}/{ShapeName}`.
+ * Legacy scheme: `https://data.lincd.org/module/{slug}/shape/{name}` — still read, because
+ * shapes materialized under the old scheme are still in stores.
+ *
+ * Falls back to the last two path segments rather than throwing. A shape from neither scheme
+ * still needs *a* short form, and a wrong-looking label is far better than a page that fails
+ * to render because one IRI was unusual.
+ */
+export function getShapeParamsFromUri(nodeShapeURI: string): string {
+  const linkedMatch = nodeShapeURI.match(/\/shape\/([^/]+)\/([^/]+)$/);
+  if (linkedMatch) return `${linkedMatch[1]}:${linkedMatch[2]}`;
+
+  const legacyMatch = nodeShapeURI.match(/module\/(.*?)\/shape\/([^/]+)$/);
+  if (legacyMatch) return `${legacyMatch[1]}:${legacyMatch[2]}`;
+
+  const parts = nodeShapeURI.split('/');
+  return `${parts[parts.length - 2]}:${parts[parts.length - 1]}`;
+}
+
+/** The display name from a short form: `irl:ActionPlan` → `Action Plan`. */
+export function getShapeNameFromParams(str: string): string {
+  const lastWord = str.split(':').pop() ?? str;
+  return formatShapeLabel(lastWord.charAt(0).toUpperCase() + lastWord.slice(1));
+}

package/src/shape/nodeDisplay.ts

@@ -0,0 +1,114 @@
+import { Prefix } from '@_linked/core/utils/Prefix';
+
+/**
+ * Centralized label resolution for any node/value in the CMS.
+ * Handles NamedNode objects, Literal values, and plain strings consistently.
+ * Never returns [object Object].
+ */
+export function getNodeDisplay(value: any): string {
+  if (value == null) return '';
+
+  // Primitives: string, number, boolean
+  if (typeof value === 'string') return value;
+  if (typeof value === 'number') return String(value);
+  if (typeof value === 'boolean') return value ? 'Yes' : 'No';
+
+  // Object with label/name/identifier fields (Shape, QResult, etc.)
+  if (typeof value === 'object') {
+    if (value.label) return String(value.label);
+    if (value.name) return String(value.name);
+    if (value.identifier) return String(value.identifier);
+
+    // NamedNode with URI — try prefixed form, else last URI segment
+    const uri = value.uri || value.id;
+    if (typeof uri === 'string' && uri.length > 0) {
+      return toPrefixedOrSegment(uri);
+    }
+
+    // Literal with .value
+    if (value.value != null) return String(value.value);
+  }
+
+  // Final fallback — never [object Object]
+  return String(value);
+}
+
+/**
+ * Convert a raw enum value label into a human-readable string.
+ * - camelCase → "Camel Case" (e.g., "inPerson" → "In Person")
+ * - already spaced/titled → unchanged
+ * - short lowercase → capitalized (e.g., "home" → "Home")
+ */
+export function humanizeEnumLabel(raw: string): string {
+  if (!raw) return '';
+  // If it already contains spaces, just ensure first letter is capitalized
+  if (raw.includes(' ')) {
+    return raw.charAt(0).toUpperCase() + raw.slice(1);
+  }
+  // Split on camelCase boundaries: "inPerson" → ["in", "Person"]
+  const parts = raw.replace(/([a-z])([A-Z])/g, '$1 $2').split(' ');
+  return parts
+    .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+    .join(' ');
+}
+
+/**
+ * Try to get a prefixed URI (e.g., "irlcg:Team"), else extract the last path segment.
+ */
+function toPrefixedOrSegment(uri: string): string {
+  try {
+    const prefixed = Prefix.toPrefixedIfPossible(uri);
+    if (prefixed !== uri) return prefixed;
+  } catch {
+    // Prefix resolution not available
+  }
+  // Extract last path segment or fragment
+  const hashIdx = uri.lastIndexOf('#');
+  if (hashIdx >= 0) return uri.slice(hashIdx + 1);
+  const slashIdx = uri.lastIndexOf('/');
+  if (slashIdx >= 0) return uri.slice(slashIdx + 1);
+  return uri;
+}
+
+/** The part of an IRI a person reads: everything after the last `#` or `/`. */
+function localPart(iri: string): string {
+  const hash = iri.lastIndexOf('#');
+  if (hash >= 0) return iri.slice(hash + 1);
+  const slash = iri.lastIndexOf('/');
+  return slash >= 0 ? iri.slice(slash + 1) : iri;
+}
+
+/**
+ * The choices for an enumerated property, as `{id, label}` pairs.
+ *
+ * `sh:in` holds its members as the metamodel does — an IRI stays a reference, a literal stays
+ * a literal — and carries **no label**. The DTO this package used to take carried `inValues`
+ * with a label attached, but that label was never in the graph: it was the IRI's local part,
+ * derived at projection time. Deriving it here instead is the same answer from one place, and
+ * it is what lets the components drop the DTO.
+ *
+ * Three call sites needed it — the filter drawer, the form field, and validation — and each
+ * had its own idea of how to unwrap a member. One rule now.
+ */
+export function enumOptions(property: {
+  in?: unknown[];
+  /** The DTO's spelling, still accepted so a host holding one is not turned away. */
+  inValues?: {id: string; label?: string}[];
+}): {id: string; label: string}[] {
+  const members = property.in ?? property.inValues;
+  if (!Array.isArray(members) || members.length === 0) return [];
+  return members.map((member) => {
+    if (member !== null && typeof member === 'object') {
+      const {id, label} = member as {id?: unknown; label?: unknown};
+      const value = String(id ?? '');
+      return {
+        id: value,
+        label: typeof label === 'string' ? label : humanizeEnumLabel(localPart(value)),
+      };
+    }
+    // A literal enumeration — `sh:in ("red" "green")`. Its own value is its identity, and
+    // there is no IRI to take a local part of.
+    const value = String(member);
+    return {id: value, label: humanizeEnumLabel(value)};
+  });
+}