Glossy

https://github.com/swaits-typst-packages/glossy
Admin
Glossy is a Typst package that provides utilities to manage and render glossaries within documents,...
Tokens:7,505
Snippets:51
Trust Score:4.3
License:MIT
Update:9 months ago
Show doc for...
Tokens:
Raw
### Define and Initialize Glossary Terms

Source: https://github.com/swaits-typst-packages/glossy/blob/main/README.md

Initializes a glossary using the 'init-glossary' function with a dictionary of terms. Each term can have short and long forms, descriptions, groups, and pluralization overrides. This example demonstrates both concise and detailed term definitions.

```typst
#let myGlossary = (
    html: (
      short: "HTML",
      long: "Hypertext Markup Language",
      description: "A standard language for creating web pages",
      group: "Web"
    ),
    css: (
      short: "CSS",
      long: "Cascading Style Sheets",
      description: "A stylesheet language used for describing the presentation of a document",
      group: "Web"
    ),
    tps: (
      short: "TPS",
      long: "test procedure specification",
      description: "A formal document describing test steps and expected results",
      // Optional: Override automatic pluralization
      plural: "TPSes",
      longplural: "test procedure specifications"
    ),
    WWW: "World Wide Web", // concise entry with only short: long
)

#show: init-glossary.with(myGlossary)
```

--------------------------------

### Define Custom Glossary Theme (Typst)

Source: https://github.com/swaits-typst-packages/glossy/blob/main/README.md

Create a custom theme for the glossary by defining a dictionary with `section`, `group`, and `entry` functions. This example shows how to structure these functions to format the glossary title, term groups, and individual entries.

```typst
#let my-theme = (
  // Main glossary section
  section: (title, body) => {
    heading(level: 1, title)
    body
  },

  // Group of related terms
  group: (name, index, total, body) => {
    // index = group index, total = total groups
    if name != "" and total > 1 {
      heading(level: 2, name)
    }
    body
  },

  // Individual glossary entry
  entry: (entry, index, total) => {
    // index = entry index, total = total entries in group
    let output = [#entry.short#entry.label] // **NOTE:** Label here!
    if entry.long != none {
      output = [#output -- #entry.long]
    }
    if entry.description != none {
      output = [#output: #entry.description]
    }
    block(
      grid(
        columns: (auto, 1fr, auto),
        output,
        repeat([#h(0.25em) . #h(0.25em)]),
        entry.pages,
      )
    )
  }
)
```

--------------------------------

### Initialize Glossary with Custom Styling (Typst)

Source: https://context7.com/swaits-typst-packages/glossy/llms.txt

Initializes the Typst glossary system using the `init-glossary` function. This example demonstrates defining glossary entries directly within the Typst code and applying custom styling to terms using the `show-term` parameter. It also enables clickable term links.

```typst
#import "@preview/glossy:0.8.0": *

// Define glossary entries as a dictionary
#let myGlossary = (
  html: (
    short: "HTML",
    long: "Hypertext Markup Language",
    description: "A standard language for creating web pages",
    group: "Web"
  ),
  css: (
    short: "CSS",
    long: "Cascading Style Sheets",
    description: "A stylesheet language for document presentation",
    group: "Web"
  ),
  tps: (
    short: "TPS",
    long: "test procedure specification",
    description: "A formal document describing test steps and expected results",
    plural: "TPSes",  // Override automatic pluralization
    longplural: "test procedure specifications"
  ),
  api: "Application Programming Interface",  // Abbreviated syntax: key=short, value=long
)

// Initialize glossary with custom term styling
#show: init-glossary.with(
  myGlossary,
  show-term: (body) => emph(body),  // Italicize all terms
  term-links: true  // Make terms clickable links to glossary
)

// Now use terms in your document
In modern web development, @html and @css are essential.
The @tps:pl need to be submitted by Friday.

```

--------------------------------

### Glossary Term Definition in YAML

Source: https://github.com/swaits-typst-packages/glossy/blob/main/README.md

Example of a glossary definition in YAML format, which can be loaded by the 'init-glossary' function. It includes fields like 'short', 'long', 'description', 'group', and overrides for pluralization.

```yaml
html:
  short: HTML
  article: an
  long: Hypertext Markup Language
  longarticle: a
  description: A standard language for creating web pages
  group: Web

css:
  short: CSS
  long: Cascading Style Sheets
  description: A stylesheet language used for describing the presentation of a document
  group: Web

tps:
  short: TPS
  long: test procedure specification
  description: A formal document describing test steps and expected results
  plural: TPSes
  longplural: test procedure specifications

WWW: World Wide Web
```

--------------------------------

### Load Glossary from External YAML File (Typst)

Source: https://context7.com/swaits-typst-packages/glossy/llms.txt

Loads glossary entries from an external YAML file using Typst's `yaml()` function and initializes the glossary system with `init-glossary`. This approach separates glossary definitions from the main document content, promoting better organization. The example assumes a `glossary.yaml` file exists in the same directory.

```typst
#import "@preview/glossy:0.8.0": *

// Load glossary from external YAML file
#show: init-glossary.with(yaml("glossary.yaml"))

// Terms are now available for use
The @html standard defines web page structure.

```

--------------------------------

### Customize Term Display with show-term Function (Typst)

Source: https://github.com/swaits-typst-packages/glossy/blob/main/README.md

Control how terms are displayed in the document by providing a custom `show-term` function to `init-glossary`. This example uses `emph-term` to emphasize the term body.

```typst
#let emph-term(term-body) = { emph(term-body) }

#show: init-glossary.with(
  myGlossary,
  show-term: emph-term
)
```

--------------------------------

### Glossary Definitions (YAML)

Source: https://context7.com/swaits-typst-packages/glossy/llms.txt

Example structure for defining glossary terms in a YAML file. Each term can have properties like `short`, `long`, `description`, `group`, `plural`, and `longplural`. The `article` and `longarticle` fields can be used for automatic 'a'/'an' detection.

```yaml
# glossary.yaml
html:
  short: HTML
  article: an
  long: Hypertext Markup Language
  longarticle: a
  description: A standard language for creating web pages
  group: Web

css:
  short: CSS
  long: Cascading Style Sheets
  description: A stylesheet language for document presentation
  group: Web

tps:
  short: TPS
  long: test procedure specification
  description: A formal document describing test steps
  plural: TPSes
  longplural: test procedure specifications

api: Application Programming Interface

```

--------------------------------

### Glossary Entry Fields in Typst Glossy

Source: https://context7.com/swaits-typst-packages/glossy/llms.txt

Details the various fields available for defining glossary entries, including required and optional parameters that control the display and indexing of terms. It shows examples of complete, minimal, and abbreviated entry definitions.

```typst
#import "@preview/glossy:0.8.0": *

#let complete-glossary = (
  // Full entry with all fields
  example: (
    short: "Ex",                    // Required: Short form/abbreviation
    long: "Example Term",           // Optional: Long form/full name
    description: "A sample entry",  // Optional: Definition/description
    group: "Samples",               // Optional: Category for grouping
    article: "an",                  // Optional: Article for short form (a/an)
    longarticle: "an",              // Optional: Article for long form
    plural: "Exs",                  // Optional: Override auto-pluralization
    longplural: "Example Terms",    // Optional: Override long form plural
  ),

  // Minimal entry (only short required)
  min: (
    short: "MIN",
  ),

  // Entry with just short and long
  mid: (
    short: "MID",
    long: "Middle Entry",
  ),

  // Abbreviated syntax: key becomes short, value becomes long
  abbrev: "Abbreviated Entry",
)

#show: init-glossary.with(complete-glossary)

// All entry types work with references
@example, @min, @mid, @abbrev
```

--------------------------------

### Load Glossary from YAML File

Source: https://github.com/swaits-typst-packages/glossy/blob/main/README.md

Initializes the glossary by loading terms from a YAML file named 'glossary.yaml'. This allows for external management of glossary data, separating content from presentation logic.

```typst
#show: init-glossary.with(yaml("glossary.yaml"))
```

--------------------------------

### Initialize Glossary with Entries (Typst)

Source: https://context7.com/swaits-typst-packages/glossy/llms.txt

Initializes the Glossy glossary with a set of predefined entries. This function should be called early in the Typst document. It takes a dictionary of entries as input.

```typst
#show: init-glossary.with(entries: (
  "term1": "Definition 1",
  "term2": "Definition 2"
))
```

--------------------------------

### Using Built-in Glossy Themes

Source: https://context7.com/swaits-typst-packages/glossy/llms.txt

Demonstrates how to import and apply various built-in themes provided by the glossy package for different glossary rendering styles. This includes academic, basic, compact, table, two-column, and Chicago index formats.

```typst
#import "@preview/glossy:0.8.0": *

#let myGlossary = (
  html: (short: "HTML", long: "Hypertext Markup Language",
         description: "A standard language for creating web pages"),
  css: (short: "CSS", long: "Cascading Style Sheets",
        description: "A stylesheet language for document presentation"),
  api: (short: "API", long: "Application Programming Interface",
        description: "A software interface specification"),
)

#show: init-glossary.with(myGlossary)
#set page(numbering: "1")

// Use terms
Working with @html, @css, and @api.

// theme-academic (default): Bold terms, descriptions, page numbers in grid
#glossary(theme: theme-academic)

// theme-basic: Traditional format with indented descriptions
#glossary(theme: theme-basic)

// theme-compact: Space-efficient with smaller fonts and minimal spacing
#glossary(theme: theme-compact)

// theme-table: Tabular format with columns for abbreviation, name, description, pages
#glossary(theme: theme-table)

// theme-twocol: Two-column layout for longer glossaries
#glossary(theme: theme-twocol)

// theme-chicago-index: Chicago Manual of Style index format
#glossary(theme: theme-chicago-index)
```

--------------------------------

### Generate Glossary Output (Typst)

Source: https://github.com/swaits-typst-packages/glossy/blob/main/README.md

Illustrates the usage of the `glossary()` function in Typst to generate and display the compiled glossary. It covers optional parameters for setting a title, theme, sorting behavior, case sensitivity, filtering by groups, and showing all terms regardless of reference.

```typst
#glossary(
  title: "Web Development Glossary", // Optional: defaults to Glossary
  theme: my-theme, // Optional: defaults to theme-academic
  sort: true, // Optional: whether or not to sort the glossary
  ignore-case: false, // Optional: ignore case when sorting terms
  groups: ("Web"),  // Optional: Filter to specific groups
  show-all: false, // Optional; Show all terms even if unreferenced
)
```

--------------------------------

### Creating Custom Glossy Themes

Source: https://context7.com/swaits-typst-packages/glossy/llms.txt

Illustrates how to define and use a custom theme for the glossy package by providing custom functions for rendering the glossary section, term groups, and individual entries. This allows for highly customized glossary layouts.

```typst
#import "@preview/glossy:0.8.0": *

// Define a custom theme
#let my-custom-theme = (
  // Renders the main glossary section
  // Parameters: title (string), body (content)
  section: (title, body) => {
    heading(level: 1, title)
    v(1em)
    body
  },

  // Renders a group of related terms
  // Parameters: name (string), index (int), total (int), body (content)
  group: (name, index, total, body) => {
    if name != "" and total > 1 {
      heading(level: 2, name)
    }
    body
  },

  // Renders a single glossary entry
  // Parameters: entry (dictionary), index (int), total (int)
  // entry contains: short, long, description, label, pages
  entry: (entry, index, total) => {
    let output = [*#entry.short*#entry.label]  // NOTE: label is required for term linking
    if entry.long != none {
      output = [#output -- #entry.long]
    }
    if entry.description != none {
      output = [#output: #entry.description]
    }
    block(
      grid(
        columns: (auto, 1fr, auto),
        output,
        repeat([#h(0.25em) . #h(0.25em)]),
        entry.pages,
      )
    )
  }
)

#let myGlossary = (
  html: (short: "HTML", long: "Hypertext Markup Language",
         description: "Web markup language", group: "Web"),
  css: (short: "CSS", long: "Cascading Style Sheets",
        description: "Stylesheet language", group: "Web"),
  api: (short: "API", long: "Application Programming Interface",
        description: "Software interface"),
)

#show: init-glossary.with(myGlossary)
#set page(numbering: "1")

Using @html, @css, and @api in this document.

#glossary(theme: my-custom-theme)
```

--------------------------------

### Reference Glossary Terms with Modifiers (Typst)

Source: https://github.com/swaits-typst-packages/glossy/blob/main/README.md

Demonstrates how to reference glossary terms using Typst's @reference syntax and various available modifiers like 'cap', 'pl', 'both', 'short', 'long', 'def', 'noref', and 'a'/'an'. Modifiers can be combined using colons to control the output format, capitalization, plurality, and inclusion of articles or descriptions.

```typst
In modern web development, languages like @html and @css are essential.
The @tps:pl need to be submitted by Friday.

#glossary(
  title: "Web Development Glossary",
  theme: my-theme,
  sort: true,
  ignore-case: false,
  groups: ("Web"),
  show-all: false,
)

#glossary(groups: ("", "Web"))
#glossary(groups: (" "))
```

--------------------------------

### Customize Glossary Appearance with Theme (Typst)

Source: https://context7.com/swaits-typst-packages/glossy/llms.txt

Applies a built-in theme to customize the appearance of the generated glossary. The `theme` parameter accepts predefined theme names. Custom themes can also be created for specific styling needs.

```typst
#show: init-glossary.with(entries: (...), theme: "academic")
```

--------------------------------

### Import Glossy Package

Source: https://github.com/swaits-typst-packages/glossy/blob/main/README.md

Imports all functionalities from the 'glossy' package version 0.8.0. This is the first step to using the package's features in a Typst document.

```typst
#import "@preview/glossy:0.8.0": *
```

--------------------------------

### Load Glossary Entries from YAML (Typst)

Source: https://context7.com/swaits-typst-packages/glossy/llms.txt

Loads glossary entries from an external YAML file. This promotes maintainability for large sets of terms. Ensure the YAML file is correctly formatted with term keys and their definitions.

```typst
#let entries = yaml("path/to/your/glossary.yaml")
#show: init-glossary.with(entries: entries)
```

--------------------------------

### Load Glossary Entries from JSON (Typst)

Source: https://context7.com/swaits-typst-packages/glossy/llms.txt

Loads glossary entries from an external JSON file. This is an alternative to YAML for managing term definitions externally. The JSON structure should map terms to their definitions.

```typst
#let entries = json("path/to/your/glossary.json")
#show: init-glossary.with(entries: entries)
```

--------------------------------

### Typst Glossary Rendering

Source: https://context7.com/swaits-typst-packages/glossy/llms.txt

Explains how to render the glossary section using the 'glossary()' function. This function displays referenced terms, organized by groups with page backlinks. It supports filtering by groups, custom sorting (case-sensitive or insensitive), and showing all terms including unreferenced ones.

```typst
#import "@preview/glossy:0.8.0": *

#let myGlossary = (
  html: (short: "HTML", long: "Hypertext Markup Language",
         description: "Web page markup language", group: "Web"),
  css: (short: "CSS", long: "Cascading Style Sheets",
        description: "Stylesheet language", group: "Web"),
  api: (short: "API", long: "Application Programming Interface",
        description: "Software interface specification", group: "Programming"),
  sdk: (short: "SDK", long: "Software Development Kit",
        description: "Development tools package", group: "Programming"),
)

#show: init-glossary.with(myGlossary)
#set page(numbering: "1")

// Reference terms in document
Working with @html and @css for web development.
Using the @api and @sdk for application development.

// Basic glossary with defaults
#glossary()

// Glossary with custom title
#glossary(title: "Technical Terms")

// Filter to specific groups
#glossary(title: "Web Technologies", groups: ("Web",))

// Show ungrouped terms only (empty string = no group)
#glossary(groups: ("",))

// Multiple groups in specific order
#glossary(groups: ("Web", "Programming"))

// Show all terms including unreferenced ones
#glossary(show-all: true)

// Disable sorting (use definition order)
#glossary(sort: false)

// Case-insensitive sorting
#glossary(sort: true, ignore-case: true)

```

--------------------------------

### Typst Term Reference Modifiers

Source: https://context7.com/swaits-typst-packages/glossy/llms.txt

Demonstrates how to reference terms using Typst's '@reference' syntax with various modifiers. Modifiers control capitalization, pluralization, display form (short, long, both), and whether the term appears in the glossary index. It also shows how to force specific forms, add articles, exclude from index, hide references, and override display text.

```typst
#import "@preview/glossy:0.8.0": *

#let glossary-data = (
  tps: (
    short: "TPS",
    long: "test procedure specification",
    description: "A formal document describing test steps",
    plural: "TPSes",
    longplural: "test procedure specifications"
  ),
)

#show: init-glossary.with(glossary-data)

// Basic usage - first use shows "long (short)", subsequent shows "short"
First mention: @tps           // Output: "test procedure specification (TPS)"
Second mention: @tps          // Output: "TPS"

// Force specific forms
@tps:short                    // Output: "TPS"
@tps:long                     // Output: "test procedure specification"
@tps:both                     // Output: "test procedure specification (TPS)"

// Capitalization
@tps:long:cap                 // Output: "Test procedure specification"
@tps:both:cap                 // Output: "Test procedure specification (TPS)"

// Pluralization
@tps:long:pl                  // Output: "test procedure specifications"
@tps:short:pl                 // Output: "TPSes"
@tps:both:pl:cap              // Output: "Test procedure specifications (TPSes)"

// Show description/definition
@tps:def                      // Output: "A formal document describing test steps"
@tps:desc                     // Same as :def

// Articles (a/an) - can precede or follow the key
@a:tps:short                  // Output: "a TPS"
@tps:an:long                  // Output: "a test procedure specification"
@an:tps:both:cap              // Output: "A test procedure specification (TPS)"

// Exclude from glossary index
@tps:noref                    // Displays term but won't show in glossary
@tps:noindex                  // Same as :noref

// Hidden reference (counts for glossary but displays nothing)
@tps:hidden                   // No visible output, term appears in glossary

// Override display text entirely
@tps[custom text]             // Output: "custom text" (still tracked as TPS reference)

```

--------------------------------

### Reference a Term (Typst)

Source: https://context7.com/swaits-typst-packages/glossy/llms.txt

References a defined term within a Typst document using the Glossy package. The term will be automatically formatted and its page number recorded for the glossary. Usage is straightforward with the `@term` syntax.

```typst
This is a reference to @term1.
```

--------------------------------

### Override Glossary Term Text (Typst)

Source: https://github.com/swaits-typst-packages/glossy/blob/main/README.md

Shows how to completely control the displayed text for a glossary term by providing custom text within square brackets after the term reference. This allows for specific phrasing that deviates from the default term definition.

```typst
@tps[an annoying report]
```

--------------------------------

### Use Term Modifiers for Fine-Grained Control (Typst)

Source: https://context7.com/swaits-typst-packages/glossy/llms.txt

Applies modifiers to a term reference for specific formatting or behavior, such as forcing pluralization or overriding automatic article detection. This allows for precise control over term presentation.

```typst
The @term1(plural: true) are defined here.
```
Tokens:
Raw