@bendyline/squisq 2.0.1 → 2.2.0

package/src/icons/index.ts

@@ -1,26 +0,0 @@
-/**
- * Icons barrel — subpath `@bendyline/squisq/icons`.
- *
- * Exposes the FontAwesome Free catalog (`ICONS`, `IconEntry`,
- * `IconFamily`) and the lookup helpers (`resolveIcon`,
- * `canonicalIconToken`, `looksLikeIconToken`).
- */
-
-export { ICONS } from './iconData.js';
-export type { IconEntry, IconFamily } from './iconData.js';
-export {
-  resolveIcon,
-  canonicalIconToken,
-  looksLikeIconToken,
-  suggestIcons,
-  iconGlyph,
-} from './resolve.js';
-export type { IconSuggestion } from './resolve.js';
-export {
-  iconMarker,
-  hasIconMarker,
-  stripIconMarkers,
-  splitIconMarkers,
-  iconClass,
-} from './inlineIconMarker.js';
-export type { IconTextRun } from './inlineIconMarker.js';

package/src/icons/inlineIconMarker.ts

@@ -1,73 +0,0 @@
-/**
- * Inline-icon markers for template text.
- *
- * Slide templates flatten rich markdown body content into strings before
- * rendering. Inline icons need to survive that flattening step, so we encode
- * them as sentinel-delimited text markers and let `TextLayer` turn them back
- * into FontAwesome glyphs when rendering.
- */
-
-import type { IconFamily } from './iconData.js';
-
-/**
- * Private-Use-Area sentinel that brackets an encoded icon.
- * Kept as an escape sequence so the source remains valid TypeScript text.
- */
-const SENTINEL = '\uE000';
-
-/** Matches one encoded marker: `<sentinel><family>:<name><sentinel>`. */
-const MARKER_RE = new RegExp(`${SENTINEL}([a-z]+):([a-zA-Z0-9-]+)${SENTINEL}`, 'g');
-
-/** Encode a resolved icon (family + name) as an embeddable text marker. */
-export function iconMarker(family: IconFamily, name: string): string {
-  return `${SENTINEL}${family}:${name}${SENTINEL}`;
-}
-
-/** True when a string contains at least one encoded icon marker. */
-export function hasIconMarker(value: string): boolean {
-  return value.includes(SENTINEL);
-}
-
-/** Remove every icon marker, leaving a clean plain-text projection. */
-export function stripIconMarkers(value: string): string {
-  return value.replace(MARKER_RE, '');
-}
-
-/** A run of a marker-bearing string: literal text or a resolved icon. */
-export type IconTextRun =
-  | { type: 'text'; text: string }
-  | { type: 'icon'; family: IconFamily; name: string };
-
-/**
- * Split a string into ordered text/icon runs. Text between markers is
- * preserved verbatim, including whitespace; each marker becomes an icon run.
- */
-export function splitIconMarkers(value: string): IconTextRun[] {
-  const runs: IconTextRun[] = [];
-  let lastIndex = 0;
-  MARKER_RE.lastIndex = 0;
-
-  let match: RegExpExecArray | null;
-  while ((match = MARKER_RE.exec(value)) !== null) {
-    if (match.index > lastIndex) {
-      runs.push({ type: 'text', text: value.slice(lastIndex, match.index) });
-    }
-    runs.push({
-      type: 'icon',
-      family: match[1] as IconFamily,
-      name: match[2],
-    });
-    lastIndex = match.index + match[0].length;
-  }
-
-  if (lastIndex < value.length) {
-    runs.push({ type: 'text', text: value.slice(lastIndex) });
-  }
-
-  return runs;
-}
-
-/** FontAwesome CSS class for a resolved icon, e.g. `fa-solid fa-rocket`. */
-export function iconClass(family: IconFamily, name: string): string {
-  return `fa-${family} fa-${name}`;
-}

package/src/icons/resolve.ts

@@ -1,139 +0,0 @@
-/**
- * Icon Resolver
- *
- * Looks up a user-supplied token against the FontAwesome Free catalog.
- *
- * Tokens come in two forms:
- * - **Bare** (`github`) — resolves only when the name is unique across
- *   families. The picker prefers this form for friendliness.
- * - **Qualified** (`fa-brands:github`, `fa-solid:user`) — required when
- *   the name collides across families (e.g. `user` ships in both solid
- *   and regular).
- *
- * Returning `null` from `resolveIcon` is a deliberate signal: callers
- * should render the source token verbatim so authors can write
- * `{[notathing]}` in prose without it being silently swallowed.
- */
-
-import { ICONS } from './iconData.js';
-import type { IconEntry, IconFamily } from './iconData.js';
-
-// Index built once per module: name → IconEntry[]. Multi-entry buckets
-// indicate cross-family collisions that require a qualified token.
-const BY_NAME = new Map<string, IconEntry[]>();
-for (const entry of ICONS) {
-  const bucket = BY_NAME.get(entry.name);
-  if (bucket) bucket.push(entry);
-  else BY_NAME.set(entry.name, [entry]);
-}
-
-const FAMILY_PREFIXES: Record<string, IconFamily> = {
-  'fa-brands': 'brands',
-  'fa-solid': 'solid',
-  'fa-regular': 'regular',
-  brands: 'brands',
-  solid: 'solid',
-  regular: 'regular',
-};
-
-/**
- * True when a token looks like an icon reference. Used by the markdown
- * parser to decide whether a `{[…]}` body in a heading is worth probing
- * (the heading-template path already extracted the trailing annotation
- * by the time inline detection runs).
- */
-export function looksLikeIconToken(token: string): boolean {
-  return /^[a-zA-Z0-9_:-]+$/.test(token);
-}
-
-/**
- * Resolve a token to an icon. Returns `null` when the token is unknown
- * OR when the bare form collides — callers should render `null` results
- * as literal markdown text so authors can opt out by qualifying.
- */
-export function resolveIcon(token: string): IconEntry | null {
-  if (!looksLikeIconToken(token)) return null;
-  // Qualified form: `<family-prefix>:<name>`.
-  const colon = token.indexOf(':');
-  if (colon > 0) {
-    const prefix = token.slice(0, colon);
-    const name = token.slice(colon + 1);
-    const family = FAMILY_PREFIXES[prefix];
-    if (!family) return null;
-    const bucket = BY_NAME.get(name);
-    return bucket?.find((e) => e.family === family) ?? null;
-  }
-  // Bare form: must be unique across families.
-  const bucket = BY_NAME.get(token);
-  if (!bucket || bucket.length !== 1) return null;
-  return bucket[0];
-}
-
-/**
- * The canonical "shortest unambiguous" token for an icon — bare if the
- * name is unique, otherwise the qualified form. Used when serializing
- * a resolved icon back to markdown so we don't gratuitously qualify
- * names that don't need it.
- */
-export function canonicalIconToken(entry: IconEntry): string {
-  const bucket = BY_NAME.get(entry.name);
-  if (bucket && bucket.length === 1) return entry.name;
-  return `fa-${entry.family}:${entry.name}`;
-}
-
-/**
- * Render the icon's Unicode codepoint as a single-character string.
- * Returns `''` for entries without a codepoint (defensive — FA always
- * has one). Used by editors and previews that want to display the
- * actual glyph using the FontAwesome font; pair with the right
- * font-family/font-weight for the icon's family.
- */
-export function iconGlyph(entry: IconEntry): string {
-  if (!entry.unicode) return '';
-  const code = parseInt(entry.unicode, 16);
-  if (!Number.isFinite(code)) return '';
-  return String.fromCodePoint(code);
-}
-
-/** Single autocomplete suggestion. `score` ranks lower-is-better:
- *  0 = name starts-with query, 1 = name contains query,
- *  2 = keyword contains query. */
-export interface IconSuggestion {
-  entry: IconEntry;
-  token: string;
-  score: number;
-}
-
-/**
- * Rank icons against a partial token typed by the user. Used by the
- * Monaco completion provider in editor-react and re-exported so any
- * host can build its own typeahead.
- */
-export function suggestIcons(query: string, limit = 50): IconSuggestion[] {
-  const q = query.trim().toLowerCase();
-  const matches: IconSuggestion[] = [];
-  for (const icon of ICONS) {
-    let score = -1;
-    if (!q) {
-      // Empty query — surface a few common icons. We just walk in
-      // order; the limit cuts it off.
-      score = 3;
-    } else if (icon.name.startsWith(q)) {
-      score = 0;
-    } else if (icon.name.includes(q)) {
-      score = 1;
-    } else if (icon.keywords.includes(q)) {
-      score = 2;
-    }
-    if (score < 0) continue;
-    matches.push({ entry: icon, token: canonicalIconToken(icon), score });
-    if (matches.length > 400) break; // hard cap before sort
-  }
-  matches.sort(
-    (a, b) =>
-      a.score - b.score || a.token.length - b.token.length || a.token.localeCompare(b.token),
-  );
-  return matches.slice(0, limit);
-}
-
-export type { IconEntry, IconFamily };

package/src/imageEdit/ImageEditVersionManager.ts

@@ -1,73 +0,0 @@
-/**
- * Convenience wrapper around the image-edit version operations that
- * captures a {@link ContentContainer} reference and an optional basename
- * override. Mirrors `DocumentVersionManager` in shape.
- */
-
-import type { ContentContainer } from '../storage/ContentContainer.js';
-import type { CoalesceOptions, PrunePolicy, Version } from '../versions/types.js';
-import {
-  coalesceImageEditVersions,
-  listImageEditVersions,
-  pruneImageEditVersions,
-  readImageEditVersion,
-  revertToImageEditVersion,
-  saveImageEditVersion,
-  type RevertImageEditOptions,
-  type SaveImageEditVersionOptions,
-  type SaveImageEditVersionResult,
-} from './versions.js';
-import type { ImageEditDoc } from '../schemas/ImageEditDoc.js';
-
-export interface ImageEditVersionManagerOptions {
-  /** Override the basename used in version filenames. Defaults to `'state'`. */
-  basename?: string;
-  /** Override the source filename inside the sidecar. Defaults to `state.json`. */
-  stateFilename?: string;
-}
-
-export class ImageEditVersionManager {
-  private readonly container: ContentContainer;
-  private readonly basename: string | undefined;
-  private readonly stateFilename: string | undefined;
-
-  constructor(container: ContentContainer, options: ImageEditVersionManagerOptions = {}) {
-    this.container = container;
-    this.basename = options.basename;
-    this.stateFilename = options.stateFilename;
-  }
-
-  saveVersion(options: SaveImageEditVersionOptions = {}): Promise<SaveImageEditVersionResult> {
-    return saveImageEditVersion(this.container, {
-      basename: this.basename,
-      stateFilename: this.stateFilename,
-      ...options,
-    });
-  }
-
-  listVersions(): Promise<Version[]> {
-    return listImageEditVersions(this.container, this.basename);
-  }
-
-  readVersion(version: Version | string): Promise<ImageEditDoc | null> {
-    return readImageEditVersion(this.container, version);
-  }
-
-  revertToVersion(
-    version: Version | string,
-    options: RevertImageEditOptions = {},
-  ): Promise<{ reverted: boolean; snapshotted: Version | null }> {
-    return revertToImageEditVersion(this.container, version, {
-      stateFilename: this.stateFilename,
-      ...options,
-    });
-  }
-
-  pruneVersions(policy: PrunePolicy): Promise<Version[]> {
-    return pruneImageEditVersions(this.container, policy, this.basename);
-  }
-
-  coalesceVersions(options: CoalesceOptions = {}): Promise<Version[]> {
-    return coalesceImageEditVersions(this.container, options, this.basename);
-  }
-}