@verbaly/studio 0.56.1 → 0.57.0

package/dist/panel/validate.ts

@@ -1,94 +0,0 @@
-import { parse, parseTags } from 'verbaly';
-
-// The browser preview of the gate, on the runtime's own parser: the server is still the authority.
-export interface Preview {
-  params: { name: string; inSource: boolean; inTarget: boolean }[];
-  problems: string[];
-}
-
-type Node = { kind: string; name?: string; variants?: [string, Node[]][] };
-
-function walk(nodes: Node[], out: Map<string, Set<string>>): void {
-  for (const node of nodes) {
-    if (node.kind === 'param' && node.name) {
-      if (!out.has(node.name)) out.set(node.name, new Set());
-      for (const [selector, body] of node.variants ?? []) {
-        out.get(node.name)!.add(selector);
-        walk(body, out);
-      }
-    }
-  }
-}
-
-function shape(message: string): Map<string, Set<string>> {
-  const out = new Map<string, Set<string>>();
-  try {
-    walk(parse(message) as Node[], out);
-  } catch {
-    // a half-typed message is not a defect, so an unparseable draft simply reports nothing yet
-  }
-  return out;
-}
-
-type Token = string | { name: string; children: Token[] };
-
-function collect(tokens: Token[], out: string[]): void {
-  for (const token of tokens) {
-    if (typeof token === 'string') continue;
-    out.push(token.name);
-    collect(token.children, out);
-  }
-}
-
-function tags(message: string): string[] {
-  const out: string[] = [];
-  try {
-    collect(parseTags(message) as Token[], out);
-  } catch {
-    return out;
-  }
-  return out;
-}
-
-function counted(list: string[]): Map<string, number> {
-  const out = new Map<string, number>();
-  for (const item of list) out.set(item, (out.get(item) ?? 0) + 1);
-  return out;
-}
-
-const list = (names: string[]) =>
-  names.length === 1 ? names[0] : `${names.slice(0, -1).join(', ')} and ${names.at(-1)}`;
-
-export function preview(source: string, translated: string): Preview {
-  const from = shape(source);
-  const to = shape(translated);
-  const params = [...new Set([...from.keys(), ...to.keys()])].sort().map((name) => ({
-    name,
-    inSource: from.has(name),
-    inTarget: to.has(name),
-  }));
-
-  const problems: string[] = [];
-  const lost = params.filter((p) => p.inSource && !p.inTarget).map((p) => `{${p.name}}`);
-  const made = params.filter((p) => !p.inSource && p.inTarget).map((p) => `{${p.name}}`);
-  if (lost.length) problems.push(`${list(lost)} is missing, so its value never reaches the text`);
-  if (made.length) problems.push(`${list(made)} is not in the source, so it renders as literal text`);
-
-  // a plural block that lost its catch-all renders nothing for any count it does not list
-  for (const [name, selectors] of to) {
-    if (selectors.size && !selectors.has('other')) {
-      problems.push(`the block for {${name}} has no "other" case, so some counts render empty`);
-    }
-  }
-
-  const sourceTags = counted(tags(source));
-  const targetTags = counted(tags(translated));
-  for (const [name, n] of sourceTags) {
-    if ((targetTags.get(name) ?? 0) < n) problems.push(`<${name}> is missing from the translation`);
-  }
-  for (const [name, n] of targetTags) {
-    if ((sourceTags.get(name) ?? 0) < n) problems.push(`<${name}> is not in the source message`);
-  }
-
-  return { params, problems };
-}

package/dist/panel/wire.ts

@@ -1,29 +0,0 @@
-// Every route answers JSON and every failure has to read like a sentence, so it is asked once here.
-export interface Answer<T> {
-  value?: T;
-  error?: string;
-}
-
-export async function ask<T>(
-  token: string,
-  path: string,
-  // an intersection narrows body, it does not replace it, so the fetch shape is omitted first
-  init?: Omit<RequestInit, 'body'> & { body?: unknown },
-): Promise<Answer<T>> {
-  const join = path.includes('?') ? '&' : '?';
-  let response: Response;
-  try {
-    response = await fetch(`${path}${join}t=${encodeURIComponent(token)}`, {
-      ...init,
-      headers: init?.body === undefined ? undefined : { 'content-type': 'application/json' },
-      body: init?.body === undefined ? undefined : JSON.stringify(init.body),
-    });
-  } catch {
-    return { error: '[verbaly] the studio server is not answering, is it still running?' };
-  }
-  const body = (await response.json().catch(() => ({}))) as T & { error?: string };
-  if (!response.ok) {
-    return { error: body.error ?? `[verbaly] the server answered ${response.status}` };
-  }
-  return { value: body };
-}

package/dist/panel/words.ts

@@ -1,59 +0,0 @@
-import type { MessageState } from './model';
-
-// The words are a product decision: each names a checkable fact, never a stage of a workflow.
-export const STATE: Record<MessageState, { short: string; long: string }> = {
-  done: { short: 'ready', long: 'ready' },
-  draft: { short: 'unread', long: 'written by a machine, nobody has read it' },
-  missing: { short: 'missing', long: 'missing, so your visitor sees the source language' },
-  broken: { short: 'breaks', long: 'breaks your site' },
-};
-
-export const FILTER: Record<'all' | 'look' | 'missing' | 'draft' | 'broken', string> = {
-  all: 'everything',
-  missing: 'missing',
-  draft: 'unread',
-  broken: 'breaks your site',
-  look: 'worth a look',
-};
-
-// The signals do not score a translation, they point at the few worth reading first.
-export const SIGNAL: Record<string, string> = {
-  divergent: 'the source says this two ways',
-  collision: 'came back as two translations',
-  echo: 'still identical to the source',
-  digits: 'the numbers moved',
-  url: 'a link changed',
-  code: 'a code span changed',
-};
-
-export const MARK_AS_READ = 'Mark as read';
-export const UNDO = 'Undo';
-
-// The two commands the panel can run, named by what they leave behind, not by what they are called.
-export const ACTION = {
-  find: 'Find new text',
-  findWhy: 'Reads your code and adds what your catalogs do not have yet.',
-  translate: 'Translate what is missing',
-  translateWhy: 'Calls your provider, so it costs money and takes minutes.',
-  cancel: 'Not now',
-  working: 'Reading your code',
-  running: 'Translating',
-  nothingNew: 'Nothing new: your catalogs already have every message your code uses.',
-  nothingMissing: 'Nothing missing in the languages you ticked.',
-  pickFirst: 'Tick a language to translate it.',
-  onlyLocale: 'This project has one language, so there is nothing to translate into.',
-  scanOff: 'Source scanning is off in your config, so there is nothing to read.',
-} as const;
-
-// An empty screen that tells you to click something that is not there is worse than a blank one.
-export const EMPTY = {
-  noCatalogs: 'No messages yet. Studio reads the catalogs in your project, and there are none here.',
-  oneLocale: 'One language is all you have, so there is nothing to compare it against yet.',
-  oneLocaleFix: 'Add another one to your config and it shows up in the rail.',
-  pickOne: 'Tick a language in the rail to see its translations.',
-  noMatch: 'Nothing matches. Every message here is in the state you asked for.',
-} as const;
-
-export function messages(n: number): string {
-  return `${n} ${n === 1 ? 'message' : 'messages'}`;
-}