@charz/dom-to-figma 0.0.0-stage → 0.2.5

package/dist/figma.d.mts

@@ -0,0 +1,566 @@
+//#region src/converter/nodes/image/loader.d.ts
+/**
+ * Identifier for the image being loaded. The element is included so loaders
+ * can read auxiliary attributes (`crossOrigin`, `referrerPolicy`, etc.) when
+ * choosing a fetch strategy, but `src` is the canonical key.
+ */
+type ImageRequest = {
+  src: string;
+  element: HTMLImageElement;
+};
+/**
+ * Bytes returned from the loader along with the actual content type. The
+ * package re-encodes to PNG when the type isn't directly supported by Figma's
+ * clipboard format.
+ */
+type ImageFile = {
+  bytes: ArrayBuffer;
+  mimeType: string;
+};
+type ImageLoader = (request: ImageRequest) => Promise<ImageFile>;
+/**
+ * Build an `ImageLoader` that performs a single direct `fetch(src)`. Works
+ * for same-origin images and remote images that send permissive CORS headers.
+ * Cross-origin images without CORS will throw — consumers that need a proxy
+ * chain should inject their own `ImageLoader`.
+ */
+declare function createDirectImageLoader(): ImageLoader;
+//#endregion
+//#region src/converter/types/core.d.ts
+type FigmaGuid = {
+  sessionID: number;
+  localID: number;
+};
+type FigmaTransform = {
+  m00: number;
+  m01: number;
+  m02: number;
+  m10: number;
+  m11: number;
+  m12: number;
+};
+type FigmaSize = {
+  x: number;
+  y: number;
+};
+type FigmaColor = {
+  r: number;
+  g: number;
+  b: number;
+  a: number;
+};
+type FigmaBlob = {
+  bytes: Array<number>;
+};
+//#endregion
+//#region src/converter/types/effects.d.ts
+type FigmaEffectType = "INNER_SHADOW" | "DROP_SHADOW" | "FOREGROUND_BLUR" | "BACKGROUND_BLUR";
+type FigmaBlendMode = "NORMAL" | "DARKEN" | "MULTIPLY" | "COLOR_BURN" | "LIGHTEN" | "SCREEN" | "COLOR_DODGE" | "OVERLAY" | "SOFT_LIGHT" | "HARD_LIGHT" | "DIFFERENCE" | "EXCLUSION" | "HUE" | "SATURATION" | "COLOR" | "LUMINOSITY";
+type FigmaEffectBase = {
+  type: FigmaEffectType;
+  visible: boolean;
+  radius: number;
+};
+type FigmaShadowEffect = FigmaEffectBase & {
+  type: "INNER_SHADOW" | "DROP_SHADOW";
+  color: FigmaColor;
+  offset: {
+    x: number;
+    y: number;
+  };
+  blendMode: FigmaBlendMode;
+  spread?: number;
+  showShadowBehindNode?: boolean;
+};
+type FigmaBlurEffect = FigmaEffectBase & {
+  type: "FOREGROUND_BLUR" | "BACKGROUND_BLUR";
+  color?: FigmaColor;
+  offset?: {
+    x: number;
+    y: number;
+  };
+  blendMode?: FigmaBlendMode;
+  spread?: number;
+  showShadowBehindNode?: boolean;
+};
+type FigmaEffect = FigmaShadowEffect | FigmaBlurEffect;
+//#endregion
+//#region src/converter/types/layout.d.ts
+type FigmaStackMode = "HORIZONTAL" | "VERTICAL" | "NONE";
+//#endregion
+//#region src/converter/types/paint.d.ts
+type FigmaImageScaleMode = "FILL" | "FIT" | "STRETCH" | "TILE";
+type FigmaBasePaint = {
+  opacity: number;
+  visible: boolean;
+  blendMode: string;
+  transform?: FigmaTransform;
+};
+type FigmaSolidPaint = FigmaBasePaint & {
+  type: "SOLID";
+  color: FigmaColor;
+};
+type FigmaGradientStop = {
+  color: FigmaColor;
+  position: number;
+};
+type FigmaGradientLinearPaint = FigmaBasePaint & {
+  type: "GRADIENT_LINEAR";
+  stops: Array<FigmaGradientStop>;
+};
+type FigmaGradientRadialPaint = FigmaBasePaint & {
+  type: "GRADIENT_RADIAL";
+  stops: Array<FigmaGradientStop>;
+};
+type FigmaGradientAngularPaint = FigmaBasePaint & {
+  type: "GRADIENT_ANGULAR";
+  stops: Array<FigmaGradientStop>;
+};
+type FigmaImagePaint = FigmaBasePaint & {
+  type: "IMAGE";
+  image: {
+    hash: Array<number>;
+    dataBlob?: number;
+    name?: string;
+  };
+  imageThumbnail?: {
+    hash: Array<number>;
+    name?: string;
+  };
+  imageScaleMode?: FigmaImageScaleMode;
+  animationFrame?: number;
+  imageShouldColorManage?: boolean;
+  rotation?: number;
+  scale?: number;
+  originalImageWidth?: number;
+  originalImageHeight?: number;
+  thumbHash?: Array<number>;
+  altText?: string;
+};
+type FigmaPaint = FigmaSolidPaint | FigmaImagePaint | FigmaGradientLinearPaint | FigmaGradientRadialPaint | FigmaGradientAngularPaint;
+//#endregion
+//#region src/converter/types/text.d.ts
+type FigmaTextAlignHorizontal = "LEFT" | "CENTER" | "RIGHT" | "JUSTIFIED";
+type FigmaTextDecoration = "NONE" | "UNDERLINE" | "STRIKETHROUGH";
+type FigmaTextCase = "ORIGINAL" | "UPPER" | "LOWER" | "TITLE" | "SMALL_CAPS" | "SMALL_CAPS_FORCED";
+type FigmaTextData = {
+  characters: string;
+  lines?: Array<unknown>;
+};
+type FigmaDerivedTextData = {
+  layoutSize?: {
+    x: number;
+    y: number;
+  };
+  layoutVersion?: number;
+  derivedLines: Array<{
+    directionality: "LTR" | "RTL";
+  }>;
+  fontMetaData?: Array<{
+    key: {
+      family: string;
+      style: string;
+      postscript: string;
+    };
+    fontDigest?: Array<number>;
+    fontWeight: number;
+    fontLineHeight: number;
+    fontStyle: "NORMAL" | "ITALIC";
+  }>;
+  baselines?: Array<{
+    position: {
+      x: number;
+      y: number;
+    };
+    width: number;
+    lineY: number;
+    lineHeight: number;
+    lineAscent: number;
+    firstCharacter: number;
+    endCharacter: number;
+  }>;
+  glyphs?: Array<{
+    commandsBlob: number;
+    position: {
+      x: number;
+      y: number;
+    };
+    fontSize: number;
+    firstCharacter: number;
+    advance: number;
+    rotation: number;
+  }>;
+  truncationStartIndex?: number;
+  truncatedHeight?: number;
+  logicalIndexToCharacterOffsetMap?: Array<number>;
+};
+//#endregion
+//#region src/converter/types/node.d.ts
+type FigmaBaseNodeChange = {
+  guid: FigmaGuid;
+  phase: string;
+  parentIndex?: {
+    guid: FigmaGuid;
+    position: string;
+  };
+  name: string;
+  visible: boolean;
+  opacity: number;
+  blendMode?: string;
+  size?: FigmaSize;
+  transform?: FigmaTransform;
+  mask?: boolean;
+  maskType?: string;
+  locked?: boolean;
+  autoRename?: boolean;
+};
+type FigmaTextNodeChange = FigmaBaseNodeChange & {
+  type: "TEXT";
+  fontSize?: number;
+  characters: string;
+  textAlignHorizontal?: FigmaTextAlignHorizontal;
+  textAlignVertical?: string;
+  lineHeight?: {
+    value: number;
+    units: string;
+  };
+  fontName?: {
+    family: string;
+    style: string;
+    postscript?: string;
+  };
+  textData?: FigmaTextData;
+  derivedTextData?: FigmaDerivedTextData;
+  textExplicitLayoutVersion?: number;
+  emojiImageSet?: string;
+  textDecorationSkipInk?: boolean;
+  fontVariantCommonLigatures?: boolean;
+  fontVariantContextualLigatures?: boolean;
+  fontVariantDiscretionaryLigatures?: boolean;
+  fontVariantHistoricalLigatures?: boolean;
+  fontVariantOrdinal?: boolean;
+  fontVariantSlashedZero?: boolean;
+  fontVariantNumericFigure?: string;
+  fontVariantNumericSpacing?: string;
+  fontVariantNumericFraction?: string;
+  fontVariantCaps?: string;
+  fontVariantPosition?: string;
+  letterSpacing?: {
+    value: number;
+    units: string;
+  };
+  fontVersion?: string;
+  textUserLayoutVersion?: number;
+  toggledOnOTFeatures?: Array<unknown>;
+  toggledOffOTFeatures?: Array<unknown>;
+  fontVariations?: Array<unknown>;
+  textBidiVersion?: number;
+  textTracking?: number;
+  handleMirroring?: string;
+  textAutoResize?: string;
+  detachOpticalSizeFromFontSize?: boolean;
+  textDecoration?: FigmaTextDecoration;
+  textCase?: FigmaTextCase;
+  strokeWeight?: number;
+  strokeAlign?: string;
+  strokeCap?: string;
+  strokeJoin?: string;
+  fillPaints?: Array<FigmaPaint>;
+  effects?: Array<FigmaEffect>;
+  targetAspectRatio?: {
+    value: {
+      x: number;
+      y: number;
+    };
+  };
+};
+type FigmaFrameNodeChange = FigmaBaseNodeChange & {
+  type: "FRAME";
+  fillPaints?: Array<FigmaPaint>;
+  strokePaints?: Array<FigmaPaint>;
+  effects?: Array<FigmaEffect>;
+  cornerRadius?: number;
+  backgroundOpacity?: number;
+  backgroundEnabled?: boolean;
+  strokeWeight?: number;
+  strokeAlign?: string;
+  strokeCap?: string;
+  strokeJoin?: string;
+  dashPattern?: Array<number>;
+  borderTopWeight?: number;
+  borderRightWeight?: number;
+  borderBottomWeight?: number;
+  borderLeftWeight?: number;
+  borderStrokeWeightsIndependent?: boolean;
+  rectangleTopLeftCornerRadius?: number;
+  rectangleTopRightCornerRadius?: number;
+  rectangleBottomLeftCornerRadius?: number;
+  rectangleBottomRightCornerRadius?: number;
+  rectangleCornerRadiiIndependent?: boolean;
+  rectangleCornerToolIndependent?: boolean;
+  proportionsConstrained?: boolean;
+  bordersTakeSpace?: boolean;
+  horizontalConstraint?: string;
+  verticalConstraint?: string;
+  stackMode?: FigmaStackMode;
+  stackSpacing?: number;
+  stackHorizontalPadding?: number;
+  stackVerticalPadding?: number;
+  stackPrimarySizing?: string;
+  stackPrimaryAlignItems?: string;
+  stackCounterAlignItems?: string;
+  stackChildPrimaryGrow?: number;
+  stackPaddingRight?: number;
+  stackPaddingBottom?: number;
+  stackChildAlignSelf?: string;
+  stackPositioning?: string;
+  stackWrap?: string;
+  stackCounterSpacing?: number;
+  stackReverseZIndex?: boolean;
+  minSize?: object;
+  maxSize?: object;
+  miterLimit?: number;
+  frameMaskDisabled?: boolean;
+  resizeToFit?: boolean;
+  exportBackgroundDisabled?: boolean;
+  cornerSmoothing?: number;
+  containerSupportsFillStrokeAndCorners?: boolean;
+  stackCounterSizing?: string;
+};
+type FigmaVectorNodeChange = FigmaBaseNodeChange & {
+  type: "VECTOR";
+  strokeWeight?: number;
+  strokeAlign?: string;
+  strokeCap?: string;
+  strokeJoin?: string;
+  fillPaints?: Array<FigmaPaint>;
+  strokePaints?: Array<FigmaPaint>;
+  dashPattern?: Array<number>;
+  horizontalConstraint?: string;
+  verticalConstraint?: string;
+  effects?: Array<FigmaEffect>;
+  vectorData?: {
+    vectorNetworkBlob: number;
+    normalizedSize: {
+      x: number;
+      y: number;
+    };
+  };
+};
+type FigmaGroupNodeChange = FigmaBaseNodeChange & {
+  type: "GROUP";
+};
+type FigmaCanvasNodeChange = FigmaBaseNodeChange & {
+  type: "CANVAS";
+  backgroundOpacity?: number;
+  backgroundEnabled?: boolean;
+};
+type FigmaDocumentNodeChange = FigmaBaseNodeChange & {
+  type: "DOCUMENT";
+};
+type FigmaRoundedRectangleNodeChange = FigmaBaseNodeChange & {
+  type: "ROUNDED_RECTANGLE";
+  fillPaints?: Array<FigmaPaint>;
+  strokePaints?: Array<FigmaPaint>;
+  effects?: Array<FigmaEffect>;
+  cornerRadius?: number;
+  cornerSmoothing?: number;
+  strokeWeight?: number;
+  strokeAlign?: string;
+  strokeCap?: string;
+  strokeJoin?: string;
+  dashPattern?: Array<number>;
+  targetAspectRatio?: {
+    value: {
+      x: number;
+      y: number;
+    };
+  };
+};
+type FigmaNodeChange = FigmaTextNodeChange | FigmaFrameNodeChange | FigmaVectorNodeChange | FigmaGroupNodeChange | FigmaCanvasNodeChange | FigmaDocumentNodeChange | FigmaRoundedRectangleNodeChange;
+//#endregion
+//#region src/converter/types/clipboard.d.ts
+type FigmaClipboard = {
+  type: "NODE_CHANGES";
+  sessionID: number;
+  ackID: number;
+  nodeChanges: Array<FigmaNodeChange>;
+  blobs: Array<FigmaBlob>;
+  pasteID: number;
+  pasteFileKey: string;
+  pasteIsPartiallyOutsideEnclosingFrame: boolean;
+  isCut: boolean;
+  pasteEditorType: string;
+  publishedAssetGuids: Array<string>;
+};
+//#endregion
+//#region src/converter/nodes/text/primitives/font/loader.d.ts
+/**
+ * Font properties used to request a font file. The loader is free to apply
+ * fallbacks (closest available weight, drop italic when not available, etc.)
+ * and reports the resolved values back via `FontFile`.
+ */
+type FontProperties = {
+  family: string;
+  weight: number;
+  italic: boolean;
+};
+/**
+ * Result of loading a font file. `bytes` is the raw font file (TTF, OTF,
+ * WOFF, or WOFF2 — fontkit detects the format). The optional `resolved*`
+ * fields let the loader signal that a fallback was applied.
+ *
+ * `resolvedFamily` is set when the loader could not honour the requested
+ * family and substituted bytes from a different family entirely (e.g. when
+ * the requested family isn't in the loader's catalog). The conversion still
+ * uses the *requested* family in the Figma payload — the substituted bytes
+ * exist so dom-to-figma has metrics to lay out the text. Figma resolves
+ * fonts at paste time via the user's system fonts, so a system-installed
+ * family like Verdana renders correctly even if the loader had to feed
+ * Inter bytes through the converter.
+ */
+type FontFile = {
+  bytes: ArrayBuffer;
+  resolvedWeight?: number;
+  resolvedItalic?: boolean;
+  resolvedFamily?: string;
+};
+/**
+ * A function that resolves font properties to a font file. The loader owns
+ * any catalog or fallback logic; the converter only consumes the bytes.
+ */
+type FontLoader = (request: FontProperties) => Promise<FontFile>;
+/**
+ * Options for the default fontsource-backed loader.
+ */
+type FontsourceLoaderOptions = {
+  /** Subset to request. Defaults to "latin". Common alternatives: "latin-ext", "cyrillic", "greek". */subset?: string;
+  /**
+   * Family to substitute when the requested family isn't in fontsource (web-safe
+   * fonts like Verdana, Tahoma, Georgia, Times New Roman, etc. — fontsource
+   * mirrors Google Fonts only). The substitute must itself be on fontsource.
+   * The Figma payload still claims the *requested* family name, so destinations
+   * with the system font installed render it correctly — the substituted bytes
+   * only feed conversion-time metrics.
+   *
+   * Defaults to `"Inter"`. Pass `null` to disable substitution and throw on
+   * missing families instead — the converter's per-node try/catch will then
+   * silently drop affected text nodes.
+   */
+  fallbackFamily?: string | null;
+};
+/**
+ * Build a `FontLoader` that pulls Google Fonts as static `.woff2` files from
+ * fontsource via jsDelivr's CDN. No API key, no UA tricks, browser-friendly.
+ * fontkit decompresses WOFF2 transparently.
+ *
+ * Falls back through a small chain when the exact (weight, italic) combo
+ * isn't available: drop italic, then regular 400, then throw.
+ *
+ * Families that fontsource genuinely doesn't carry (Verdana, Tahoma, etc. —
+ * fontsource mirrors Google Fonts only) are memoized after the first
+ * exhausted-with-404s attempt, so subsequent requests for the same family
+ * fail fast instead of re-hitting jsDelivr for every text node on a page.
+ * Transient failures (network, 5xx) are not memoized.
+ */
+declare function createFontsourceLoader(options?: FontsourceLoaderOptions): FontLoader;
+//#endregion
+//#region src/converter/classify.d.ts
+type ElementKind = "skip" | "group" | "frame" | "vector" | "image" | "text" | "form-with-placeholder";
+declare function defaultClassify(element: Element): ElementKind;
+//#endregion
+//#region src/converter/trace.d.ts
+/**
+ * A single entry in a {@link ConvertTrace}: the link from one emitted Figma
+ * node to the DOM element (or text node) it came from. Produced only when the
+ * converter is created with `{ trace: true }`. Consumed by the visual-parity
+ * harness to attribute discrepancies back to source DOM.
+ */
+type TraceEntry = {
+  /** GUID of the emitted node change this entry describes. */guid: FigmaGuid; /** Classified kind for the source element; always `"text"` for text nodes. */
+  kind: ElementKind; /** Lowercase tag name of the source element; `"#text"` for text nodes. */
+  tag: string;
+  /**
+   * Selector that resolves the source element from the scene root, built
+   * incrementally from real DOM child positions, e.g.
+   * `:scope > div:nth-child(2) > p:nth-child(1)`. The root element itself is
+   * `:scope`. Text nodes carry their owner element's path plus a
+   * `::text[i]` suffix (not a valid CSS selector — strip it to resolve the
+   * owner element); every line segment of one text node shares that path.
+   */
+  domPath: string; /** Source rect in viewport coordinates at convert time (`getBoundingClientRect`). */
+  rect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  }; /** First 120 characters of the rendered text; text nodes only. */
+  text?: string;
+};
+/** The full trace for one `convert()` call. Exposed as `ConvertResult.trace`. */
+type ConvertTrace = {
+  /** Root frame GUID the traced nodes descend from. */rootGuid: FigmaGuid;
+  entries: Array<TraceEntry>;
+};
+//#endregion
+//#region src/converter/walk.d.ts
+type Classify = (element: Element, defaultKind: ElementKind) => ElementKind;
+/** `"auto"` infers Figma auto-layout for flex containers; `"absolute"` keeps
+ * every frame absolutely positioned (the historical behavior). */
+type ConverterLayout = "absolute" | "auto";
+//#endregion
+//#region src/figma.d.ts
+type FrameInput = {
+  element: Element;
+  width: number;
+  height: number;
+  x: number;
+  y: number;
+  name: string;
+};
+type FigmaConverterConfig = {
+  /** Defaults to `createFontsourceLoader()` (Google Fonts via fontsource jsDelivr CDN). */fontLoader?: FontLoader; /** Defaults to `createDirectImageLoader()` (single direct `fetch(src)`). */
+  imageLoader?: ImageLoader; /** Override the default DOM-element classification. */
+  classify?: Classify;
+  /**
+   * `"auto"` (default) converts containers into Figma auto-layout frames
+   * whenever the layout can be reproduced exactly, falling back to absolute
+   * positioning per node when it can't. `"absolute"` positions every frame
+   * absolutely, disabling auto-layout inference entirely.
+   */
+  layout?: ConverterLayout;
+  /**
+   * When `true`, `convert()` also returns a {@link ConvertTrace} mapping every
+   * emitted node back to its source DOM element. Off by default and adds no
+   * cost when disabled; does not change the payload bytes. Intended for the
+   * visual-parity harness, not production copies.
+   */
+  trace?: boolean;
+};
+type SingleFrameInput = {
+  element: Element;
+  width: number;
+  height: number;
+  name?: string;
+};
+type CanvasInput = {
+  frames: ReadonlyArray<FrameInput>;
+  canvasName?: string;
+};
+type ConvertInput = SingleFrameInput | CanvasInput;
+type ConvertResult = {
+  /** Raw Figma node-change document. */document: FigmaClipboard; /** Encoded `.fig`-style binary. */
+  bytes: Uint8Array; /** Base64-encoded representation of `bytes`. */
+  base64: string; /** Construct a browser `ClipboardItem` for `navigator.clipboard.write([...])`. */
+  toClipboardItem(): ClipboardItem; /** Get the raw HTML envelope Figma reads on paste. */
+  toClipboardHtml(): string; /** DOM-to-node trace, present only when created with `{ trace: true }`. */
+  trace?: ConvertTrace;
+};
+type FigmaConverter = {
+  convert(input: ConvertInput): Promise<ConvertResult>; /** Drop cached fonts and images. Useful in long-running processes. */
+  clearCache(): void;
+};
+declare function createFigmaConverter(config?: FigmaConverterConfig): FigmaConverter;
+//#endregion
+export { CanvasInput, type Classify, ConvertInput, ConvertResult, type ConvertTrace, type ConverterLayout, type ElementKind, type FigmaClipboard, FigmaConverter, FigmaConverterConfig, type FontFile, type FontLoader, type FontProperties, type FontsourceLoaderOptions, FrameInput, type ImageFile, type ImageLoader, type ImageRequest, SingleFrameInput, type TraceEntry, createDirectImageLoader, createFigmaConverter, createFontsourceLoader, defaultClassify };
+//# sourceMappingURL=figma.d.mts.map

package/dist/figma.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"figma.d.mts","names":[],"sources":["../src/converter/nodes/image/loader.ts","../src/converter/types/core.ts","../src/converter/types/effects.ts","../src/converter/types/layout.ts","../src/converter/types/paint.ts","../src/converter/types/text.ts","../src/converter/types/node.ts","../src/converter/types/clipboard.ts","../src/converter/nodes/text/primitives/font/loader.ts","../src/converter/classify.ts","../src/converter/trace.ts","../src/converter/walk.ts","../src/figma.ts"],"mappings":"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"}