thatopen-syntax-components

Enforce ThatOpen Engine 3.3.x component lifecycle and event handling contracts.

17|1|Updated Mar 20, 2026
One-click install
npx skills add https://github.com/Impertio-Studio/ThatOpen-Claude-Skill-Package --skill thatopen-syntax-components-impertio-studio
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: thatopen-syntax-components
Source: https://github.com/Impertio-Studio/ThatOpen-Claude-Skill-Package/tree/main/skills/source/thatopen-syntax/thatopen-syntax-components
Command: npx skills add https://github.com/Impertio-Studio/ThatOpen-Claude-Skill-Package --skill thatopen-syntax-components-impertio-studio

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

It prevents common, costly mistakes when working with ThatOpen’s component system by enforcing the correct singleton access pattern, lifecycle interface contracts, and event/disposal rules.

Core Features & Use Cases

  • components.get() singleton pattern: Always obtain component instances via the registry to avoid duplicate, untracked component state.
  • Lifecycle interface contracts: Implement Disposable, Updateable, and Configurable correctly, including setup requirements for deferred initialization.
  • Event system & reactive collections: Use Event, DataMap, and DataSet patterns safely with proper handler references and reset-on-dispose practices.
  • Anti-pattern coverage: Avoid direct instantiation, missing disposal, anonymous event handler leaks, and using components after disposal.

Quick Start

Use the thatopen-syntax-components skill to review and refactor your code so all component instances are created only through components.get(), lifecycle methods follow the correct contracts, and every owned event is properly reset during dispose().

Frequently Asked Questions about thatopen-syntax-components

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I get a ThatOpen component instance correctly in Engine 3.3.x?

To get a ThatOpen component instance correctly, always use the components.get() singleton pattern from the registry. Direct instantiation causes duplicate, untracked component state, leading to runtime inconsistencies and lifecycle failures.

What is the correct way to implement Disposable and Updateable lifecycle interfaces?

Implementing Disposable and Updateable lifecycle interfaces correctly requires following strict setup contracts for deferred initialization and ensuring every owned event is properly reset during dispose(). Adhering to these lifecycle contracts prevents memory leaks and invalid state transitions.

Why do my ThatOpen DataMap and DataSet reactive collections cause memory leaks?

Reactive DataMap and DataSet collections cause memory leaks when anonymous event handler references are not properly managed. You must maintain safe Event handler references and execute reset-on-dispose practices to ensure clean teardown and prevent reactive collection update leaks.

Can I directly instantiate ThatOpen custom components instead of using the registry?

You cannot directly instantiate ThatOpen custom components. Doing so is an anti-pattern that bypasses the registry's tracking. You must register custom components and access them via components.get() to maintain valid singleton state and correct lifecycle behavior.

What are the limitations of using ThatOpen components after calling dispose()?

Using ThatOpen components after calling dispose() is an anti-pattern that causes undefined behavior because the component state is destroyed. You must ensure safe teardown by removing event subscriptions and avoiding any component access after the disposal method completes.