@formicoidea/labre-core 0.58.0 → 0.60.0

package/dist/_pkgs/affine-gfx-template/builtin/slides/consts.d.ts

@@ -0,0 +1,126 @@
+import { type Color, FontWeight } from '../../../affine-model/index.js';
+/**
+ * The slide masks' one system: geometry, typography and the two paper
+ * variants. Every mask in `masks.ts` reads these and restates none of them,
+ * so a size or a colour changes here, once, for the whole set.
+ */
+/** A 16:9 slide, the frame menu's own `16:9` preset (1600 × 900). */
+export declare const SLIDE_WIDTH = 1600;
+export declare const SLIDE_HEIGHT = 900;
+/** The side margin every mask aligns its content on. */
+export declare const SLIDE_MARGIN = 96;
+/** Where the footer line (footer text, slide number) sits. */
+export declare const SLIDE_FOOTER_Y = 846;
+/**
+ * A slide is read from across a room: its type is the document's heading
+ * scale (DESIGN.md, The Title-Ratio Rule) times one factor, so the steps
+ * between levels stay the editor's own. 1.5 puts the title at 48 model units
+ * on a 1600-wide slide, the proportion of the PO's reference deck.
+ */
+export declare const SLIDE_TYPE_FACTOR = 1.5;
+export type SlideTextRole = 'display' | 'title' | 'heading' | 'body' | 'caption' | 'figure';
+export type SlideType = {
+    fontSize: number;
+    fontWeight: FontWeight;
+};
+export declare const SLIDE_TYPE: Readonly<Record<SlideTextRole, SlideType>>;
+/**
+ * What a text box adds to its font size per line. The renderer measures the
+ * real line box in the DOM (`getLineHeight`, `gfx/text`); the seeds only need
+ * a box tall enough not to overlap the next zone.
+ *
+ * ponytail: a fixed 1.25 ratio, close to Inter's measured line box. The
+ * ceiling is a host font with a taller line box, whose seeds would overlap
+ * by a few units until edited; the upgrade is measuring with `wrapText` and
+ * `getLineHeight` at placement, which needs a DOM the snapshot build has not.
+ */
+export declare const SLIDE_LINE_HEIGHT = 1.25;
+/**
+ * The colours a slide paints with. Only `{ light, dark }` pairs of the base
+ * palette or palette values that read on both papers: a mask's elements
+ * carry no role and sit on no framework board, so they are painted as stored
+ * on a dark canvas (ADR 0039, point 6). A raw hex would leave a white slide
+ * on a dark canvas; a pair inverts with the theme.
+ */
+export type SlidePalette = {
+    /** The frame's background. */
+    paper: Color;
+    /** Titles, headings, body text, key figures. */
+    ink: Color;
+    /** Eyebrows, captions, footer, slide number, axis labels. */
+    muted: Color;
+    /** Hairlines, card outlines, the fill of a placeholder. */
+    hairline: Color;
+    /** The dashed outline of a fill zone. */
+    zoneStroke: Color;
+};
+/**
+ * Two variants, so the set reads as one deck: `paper`, a light slide that
+ * turns dark grey on a dark canvas, and `inverse`, the ink slide of a section
+ * divider, a statement or a quote, which swaps paper and ink.
+ */
+export declare const SLIDE_PALETTES: {
+    readonly paper: {
+        readonly paper: Color;
+        readonly ink: string | {
+            normal: string;
+        } | {
+            dark: string;
+            light: string;
+        };
+        readonly muted: string | {
+            normal: string;
+        } | {
+            dark: string;
+            light: string;
+        };
+        readonly hairline: {
+            dark: string;
+            light: string;
+        };
+        readonly zoneStroke: string | {
+            normal: string;
+        } | {
+            dark: string;
+            light: string;
+        };
+    };
+    readonly inverse: {
+        readonly paper: string | {
+            normal: string;
+        } | {
+            dark: string;
+            light: string;
+        };
+        readonly ink: string | {
+            normal: string;
+        } | {
+            dark: string;
+            light: string;
+        };
+        readonly muted: string | {
+            normal: string;
+        } | {
+            dark: string;
+            light: string;
+        };
+        readonly hairline: string | {
+            normal: string;
+        } | {
+            dark: string;
+            light: string;
+        };
+        readonly zoneStroke: string | {
+            normal: string;
+        } | {
+            dark: string;
+            light: string;
+        };
+    };
+};
+export type SlideVariant = keyof typeof SLIDE_PALETTES;
+/** Stroke widths, model units. */
+export declare const SLIDE_HAIRLINE_WIDTH = 2;
+export declare const SLIDE_ZONE_STROKE_WIDTH = 2;
+/** Corner radius of a card or a fill zone. */
+export declare const SLIDE_RADIUS = 12;

package/dist/_pkgs/affine-gfx-template/builtin/slides/consts.js

@@ -0,0 +1,101 @@
+import { DefaultTheme, FontWeight } from '../../../affine-model/index.js';
+import { HEADING_SCALE } from '../../../affine-shared/consts/index.js';
+import { darkThemeV2, lightThemeV2 } from '@toeverything/theme/v2';
+/**
+ * The slide masks' one system: geometry, typography and the two paper
+ * variants. Every mask in `masks.ts` reads these and restates none of them,
+ * so a size or a colour changes here, once, for the whole set.
+ */
+/** A 16:9 slide, the frame menu's own `16:9` preset (1600 × 900). */
+export const SLIDE_WIDTH = 1600;
+export const SLIDE_HEIGHT = 900;
+/** The side margin every mask aligns its content on. */
+export const SLIDE_MARGIN = 96;
+/** Where the footer line (footer text, slide number) sits. */
+export const SLIDE_FOOTER_Y = 846;
+/**
+ * A slide is read from across a room: its type is the document's heading
+ * scale (DESIGN.md, The Title-Ratio Rule) times one factor, so the steps
+ * between levels stay the editor's own. 1.5 puts the title at 48 model units
+ * on a 1600-wide slide, the proportion of the PO's reference deck.
+ */
+export const SLIDE_TYPE_FACTOR = 1.5;
+/**
+ * The doc title has no entry in `HEADING_SCALE` (it sits above the scale,
+ * DESIGN.md, Hierarchy: 700, 40px); the body is 15px. Both are restated
+ * here as the two values the scale does not carry.
+ */
+const DOC_TITLE_SIZE = 40;
+const BODY_SIZE = 15;
+const CAPTION_SIZE = 12;
+const size = (px) => Math.round(px * SLIDE_TYPE_FACTOR);
+const weight = (value) => String(value);
+export const SLIDE_TYPE = {
+    /** The cover's and a section's title: the doc title's tier. */
+    display: { fontSize: size(DOC_TITLE_SIZE), fontWeight: FontWeight.Bold },
+    /** Every slide's own title: H1. */
+    title: {
+        fontSize: size(HEADING_SCALE.h1.fontSize),
+        fontWeight: weight(HEADING_SCALE.h1.fontWeight),
+    },
+    /** A point's or a column's heading: H3. */
+    heading: {
+        fontSize: size(HEADING_SCALE.h3.fontSize),
+        fontWeight: weight(HEADING_SCALE.h3.fontWeight),
+    },
+    body: { fontSize: size(BODY_SIZE), fontWeight: FontWeight.Regular },
+    /** Footer, slide number, eyebrow, axis and placeholder labels. */
+    caption: { fontSize: size(CAPTION_SIZE), fontWeight: FontWeight.Regular },
+    /** A key figure: twice the slide title, the one number a slide is about. */
+    figure: {
+        fontSize: 2 * size(HEADING_SCALE.h1.fontSize),
+        fontWeight: FontWeight.Bold,
+    },
+};
+/**
+ * What a text box adds to its font size per line. The renderer measures the
+ * real line box in the DOM (`getLineHeight`, `gfx/text`); the seeds only need
+ * a box tall enough not to overlap the next zone.
+ *
+ * ponytail: a fixed 1.25 ratio, close to Inter's measured line box. The
+ * ceiling is a host font with a taller line box, whose seeds would overlap
+ * by a few units until edited; the upgrade is measuring with `wrapText` and
+ * `getLineHeight` at placement, which needs a DOM the snapshot build has not.
+ */
+export const SLIDE_LINE_HEIGHT = 1.25;
+const MEDIUM_GREY = DefaultTheme.StrokeColorShortMap['Grey'];
+/**
+ * The theme's one grey that has a dark side, the note palette's grey
+ * (`#e6e6e6` / `#565656`). `DefaultTheme` maps no grey note, so the pair is
+ * read from the same theme tables `getColorByKey` reads.
+ */
+const NOTE_GREY = {
+    dark: darkThemeV2['edgeless/note/grey'],
+    light: lightThemeV2['edgeless/note/grey'],
+};
+/**
+ * Two variants, so the set reads as one deck: `paper`, a light slide that
+ * turns dark grey on a dark canvas, and `inverse`, the ink slide of a section
+ * divider, a statement or a quote, which swaps paper and ink.
+ */
+export const SLIDE_PALETTES = {
+    paper: {
+        paper: DefaultTheme.NoteBackgroundColorMap['White'],
+        ink: DefaultTheme.black,
+        muted: MEDIUM_GREY,
+        hairline: NOTE_GREY,
+        zoneStroke: MEDIUM_GREY,
+    },
+    inverse: {
+        paper: DefaultTheme.black,
+        ink: DefaultTheme.white,
+        muted: MEDIUM_GREY,
+        hairline: MEDIUM_GREY,
+        zoneStroke: MEDIUM_GREY,
+    },
+};
+/** Stroke widths, model units. */
+export const SLIDE_HAIRLINE_WIDTH = 2;
+export const SLIDE_ZONE_STROKE_WIDTH = 2;
+/** Corner radius of a card or a fill zone. */
+export const SLIDE_RADIUS = 12;

package/dist/_pkgs/affine-gfx-template/builtin/slides/index.d.ts

@@ -0,0 +1,8 @@
+import type { TemplateCategory } from '../../toolbar/template-type.js';
+/**
+ * The built-in "Slides" category: one 16:9 frame per mask, ready to fill.
+ * Built in and ungated like "Other": a frame, shapes, texts and connectors
+ * are core, so no flag can take the masks away (ADR 0009 gates a framework's
+ * tooling, and a slide belongs to no framework).
+ */
+export declare const slidesTemplateCategory: TemplateCategory;

package/dist/_pkgs/affine-gfx-template/builtin/slides/index.js

@@ -0,0 +1,27 @@
+import { TEMPLATE_PANEL_CATEGORY_SLIDES } from '../../translations.js';
+import { numberSlide, slidePreview, slideSnapshot } from './build.js';
+import { SLIDE_MASKS } from './masks.js';
+function slideTemplate(mask) {
+    const [nameKey, name] = mask.name;
+    return {
+        name,
+        nameKey,
+        keywords: mask.keywords,
+        type: 'template',
+        preview: slidePreview(mask),
+        content: slideSnapshot(mask),
+        localize: std => slideSnapshot(mask, std),
+        afterInsert: numberSlide,
+    };
+}
+/**
+ * The built-in "Slides" category: one 16:9 frame per mask, ready to fill.
+ * Built in and ungated like "Other": a frame, shapes, texts and connectors
+ * are core, so no flag can take the masks away (ADR 0009 gates a framework's
+ * tooling, and a slide belongs to no framework).
+ */
+export const slidesTemplateCategory = {
+    name: TEMPLATE_PANEL_CATEGORY_SLIDES[1],
+    nameKey: TEMPLATE_PANEL_CATEGORY_SLIDES[0],
+    templates: SLIDE_MASKS.map(slideTemplate),
+};

package/dist/_pkgs/affine-gfx-template/builtin/slides/masks.d.ts

@@ -0,0 +1,83 @@
+import type { ChromeWording, TranslationParams } from '../../../affine-shared/services/index.js';
+import { type SlideTextRole, type SlideVariant } from './consts.js';
+/**
+ * The slide masks, as DATA: a mask is the list of its zones, and one builder
+ * (`build.ts`) projects every mask into a frame, its elements and its preview.
+ * Positions are model units inside the 1600 x 900 frame; sizes, weights and
+ * colours are never written here, only a text ROLE and a TONE, which
+ * `consts.ts` resolves once for the whole set.
+ *
+ * The families and the reference slides each mask stands for are in
+ * `README.md` beside this file.
+ */
+export type SlideAlign = 'left' | 'center' | 'right';
+/** A text box: a seed (or plain digits) set in one role of the type scale. */
+export type SlideTextZone = {
+    kind: 'text';
+    role: SlideTextRole;
+    /** The words, through the translation seam at placement (ADR 0023). */
+    seed?: ChromeWording;
+    params?: TranslationParams;
+    /** Digits that are no wording (an agenda's "01"). */
+    digits?: string;
+    x: number;
+    y: number;
+    w: number;
+    /** How many lines the box is sized for; the text wraps inside `w`. */
+    lines?: number;
+    align?: SlideAlign;
+    tone?: 'ink' | 'muted';
+};
+/** A fill zone: a dashed placeholder the author replaces with a picture. */
+export type SlideImageZone = {
+    kind: 'image';
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    shape?: 'rect' | 'ellipse';
+    /** Its caption, `Image` unless said otherwise (`Logo`). */
+    label?: ChromeWording;
+};
+/** A structural outline: a card, a quadrant, a Venn circle, a step. */
+export type SlideCardZone = {
+    kind: 'card';
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    shape?: 'rect' | 'ellipse';
+    /** A word set inside the card itself (a step, a milestone). */
+    label?: ChromeWording;
+    params?: TranslationParams;
+    /** `hairline` for a quiet card, `muted` for a line meant to be seen. */
+    stroke?: 'hairline' | 'muted';
+    /** A card filled with the hairline grey (a milestone bar). */
+    filled?: boolean;
+};
+/** A straight rule or arrow. */
+export type SlideLineZone = {
+    kind: 'line';
+    from: [number, number];
+    to: [number, number];
+    arrow?: boolean;
+};
+/** A filled ink dot (a timeline's milestone). */
+export type SlideDotZone = {
+    kind: 'dot';
+    x: number;
+    y: number;
+    size: number;
+};
+export type SlideZone = SlideTextZone | SlideImageZone | SlideCardZone | SlideLineZone | SlideDotZone;
+export type SlideMask = {
+    id: string;
+    /** The tile's name, also the inserted frame's title. */
+    name: ChromeWording;
+    /** Plain English search words besides the name (`Template.keywords`). */
+    keywords: string[];
+    variant: SlideVariant;
+    zones: SlideZone[];
+};
+/** Every mask, in the panel's order: a deck reads top to bottom. */
+export declare const SLIDE_MASKS: readonly SlideMask[];