createTrigger

Стабильный · с 0.1.0

Единственный конструктор в Triggery. Возвращает Trigger<Schema>, зарегистрированный в указанном рантайме (или в рантайме по умолчанию, если параметр опущен). Большинство приложений создают один триггер на сценарий — один файл на триггер.

Импорт

import { createTrigger } from '@triggery/core';

Сигнатура

function createTrigger<S extends TriggerSchema>(
  config: CreateTriggerConfig<S>,
  runtime?: Runtime,
): Trigger<S>;

Дженерик S — это схема: три опциональные карты для событий, условий и действий. В обычном использовании он никогда не выводится, всегда передавай его явно.

Схема

type TriggerSchema = {
  events?:     Record<string, unknown>;  // payload type per event name
  conditions?: Record<string, unknown>;  // value type per condition name
  actions?:    Record<string, unknown>;  // payload type per action name
};

Для void-payload используй void (события) или undefined (действия). Имена могут быть любой валидной строкой; по соглашению — kebab-case-глаголы для событий, camelCase для условий и действий.

Config

Параметр	Тип	Обязательный	По умолчанию	Описание
`id`	`string` (литерал)	да	—	Уникальный ключ в реестре рантайма. Должен быть строковым литералом — см. `no-dynamic-id`.
`events`	`readonly EventKey<S>[]`	да	—	Имена событий из `S['events']`, на которые реагирует триггер.
`required`	`readonly ConditionKey<S>[]`	нет	`[]`	Условия, которые должны быть зарегистрированы, чтобы обработчик запустился.
`schedule`	`'microtask' \| 'sync'`	нет	`'microtask'`	Когда диспатчить подходящие события.
`concurrency`	`ConcurrencyStrategy`	нет	`'take-latest'`	Как взаимодействуют асинхронные запуски обработчика.
`scope`	`string`	нет	`''`	Ограничивает триггер поддеревом `<TriggerScope id="…">`.
`handler`	`TriggerHandler<S>`	да	—	Функция, вызываемая, когда событие совпало и условия `required` удовлетворены.

Возвращает

Объект Trigger<S> — стабильную идентичность, которую можно передавать в хуки React / Solid / Vue.

Метод	Описание
`trigger.id`	Та же строка, которую ты передал.
`trigger.enable()`	Заново включить отключённый триггер.
`trigger.disable()`	Пропускать будущие события (записывает `'disabled'` в инспектор).
`trigger.isEnabled()`	Boolean.
`trigger.inspect()`	Последний `TriggerInspectSnapshot` либо `undefined`.
`trigger.dispose()`	Снять регистрацию в рантайме. Редко — используется в тестах.
`trigger.namedHooks()`	Бросает исключение при прямом вызове в `@triggery/core` — используй `createNamedHooks` из биндинга.

Примеры

Минимальный триггер

import { createTriggerfunction createTrigger<S extends TriggerSchema>(config: CreateTriggerConfig<S>, runtime?: Runtime): Trigger<S>Create a trigger and register it in a runtime (the default runtime if none is passed).
@example```ts
const messageTrigger = createTrigger<{
  events: { 'new-message': { author: string; text: string } };
  conditions: { user: { id: string }; settings: { sound: boolean } };
  actions: { showToast: { title: string }; playSound: void };
}>({
  id: 'message-received',
  events: ['new-message'],
  required: ['user', 'settings'],
  handler({ event, conditions, actions, check }) {
    if (!conditions.user || !conditions.settings) return; // V1: manual narrowing
    if (check.is('settings', (s) => s.sound)) actions.playSound?.();
    actions.showToast?.({ title: event.payload.author });
  },
});
``` } from '@triggery/core';

const pingconst ping: Trigger<{
    events: {
        tick: number;
    };
}> = createTriggercreateTrigger<{
    events: {
        tick: number;
    };
}>(config: CreateTriggerConfig<{
    events: {
        tick: number;
    };
}>, runtime?: Runtime): Trigger<{
    events: {
        tick: number;
    };
}>Create a trigger and register it in a runtime (the default runtime if none is passed).
@example```ts
const messageTrigger = createTrigger<{
  events: { 'new-message': { author: string; text: string } };
  conditions: { user: { id: string }; settings: { sound: boolean } };
  actions: { showToast: { title: string }; playSound: void };
}>({
  id: 'message-received',
  events: ['new-message'],
  required: ['user', 'settings'],
  handler({ event, conditions, actions, check }) {
    if (!conditions.user || !conditions.settings) return; // V1: manual narrowing
    if (check.is('settings', (s) => s.sound)) actions.playSound?.();
    actions.showToast?.({ title: event.payload.author });
  },
});
```<{
  eventsevents: {
    tick: number;
}: { ticktick: number: number };
}>({
  idid: string: 'demo:ping',
  eventsevents: readonly "tick"[]: ['tick'],
  handlerhandler: TriggerHandler<{
    events: {
        tick: number;
    };
}, never>({ eventevent: {
    readonly name: "tick";
    readonly payload: number;
} }) {
    consolevar console: Console.logConsole.log(...data: any[]): voidThe **`console.log()`** static method outputs a message to the console.

[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)('tick', eventevent: {
    readonly name: "tick";
    readonly payload: number;
}.payloadpayload: number);
  },
});

Полная схема со всеми тремя картами

import { createTriggerfunction createTrigger<S extends TriggerSchema>(config: CreateTriggerConfig<S>, runtime?: Runtime): Trigger<S>Create a trigger and register it in a runtime (the default runtime if none is passed).
@example```ts
const messageTrigger = createTrigger<{
  events: { 'new-message': { author: string; text: string } };
  conditions: { user: { id: string }; settings: { sound: boolean } };
  actions: { showToast: { title: string }; playSound: void };
}>({
  id: 'message-received',
  events: ['new-message'],
  required: ['user', 'settings'],
  handler({ event, conditions, actions, check }) {
    if (!conditions.user || !conditions.settings) return; // V1: manual narrowing
    if (check.is('settings', (s) => s.sound)) actions.playSound?.();
    actions.showToast?.({ title: event.payload.author });
  },
});
``` } from '@triggery/core';

type Settingstype Settings = {
    sound: boolean;
    notifications: boolean;
} = { soundsound: boolean: boolean; notificationsnotifications: boolean: boolean };
type Messagetype Message = {
    author: string;
    text: string;
    channelId: string;
}  = { authorauthor: string: string; texttext: string: string; channelIdchannelId: string: string };

const messageTriggerconst messageTrigger: Trigger<{
    events: {
        "new-message": Message;
    };
    conditions: {
        settings: Settings;
        activeChannelId: string | null;
    };
    actions: {
        showToast: {
            title: string;
            body: string;
        };
        playSound: "beep";
    };
}> = createTriggercreateTrigger<{
    events: {
        "new-message": Message;
    };
    conditions: {
        settings: Settings;
        activeChannelId: string | null;
    };
    actions: {
        showToast: {
            title: string;
            body: string;
        };
        playSound: "beep";
    };
}>(config: CreateTriggerConfig<{
    events: {
        "new-message": Message;
    };
    conditions: {
        settings: Settings;
        activeChannelId: string | null;
    };
    actions: {
        showToast: {
            title: string;
            body: string;
        };
        playSound: "beep";
    };
}>, runtime?: Runtime): Trigger<{
    events: {
        "new-message": Message;
    };
    conditions: {
        settings: Settings;
        activeChannelId: string | null;
    };
    actions: {
        showToast: {
            title: string;
            body: string;
        };
        playSound: "beep";
    };
}>Create a trigger and register it in a runtime (the default runtime if none is passed).
@example```ts
const messageTrigger = createTrigger<{
  events: { 'new-message': { author: string; text: string } };
  conditions: { user: { id: string }; settings: { sound: boolean } };
  actions: { showToast: { title: string }; playSound: void };
}>({
  id: 'message-received',
  events: ['new-message'],
  required: ['user', 'settings'],
  handler({ event, conditions, actions, check }) {
    if (!conditions.user || !conditions.settings) return; // V1: manual narrowing
    if (check.is('settings', (s) => s.sound)) actions.playSound?.();
    actions.showToast?.({ title: event.payload.author });
  },
});
```<{
  eventsevents: {
    'new-message': Message;
}:     { 'new-message': Messagetype Message = {
    author: string;
    text: string;
    channelId: string;
} };
  conditionsconditions: {
    settings: Settings;
    activeChannelId: string | null;
}: { settingssettings: Settings: Settingstype Settings = {
    sound: boolean;
    notifications: boolean;
}; activeChannelIdactiveChannelId: string | null: string | null };
  actionsactions: {
    showToast: {
        title: string;
        body: string;
    };
    playSound: "beep";
}:    { showToastshowToast: {
    title: string;
    body: string;
}: { titletitle: string: string; bodybody: string: string }; playSoundplaySound: "beep": 'beep' };
}>({
  idid: string: 'message-received',
  eventsevents: readonly "new-message"[]: ['new-message'],
  requiredrequired?: readonly ("settings" | "activeChannelId")[] | undefinedRequired condition keys. The trigger will not run unless all of them are registered.: ['settings'],
  handlerhandler: TriggerHandler<{
    events: {
        "new-message": Message;
    };
    conditions: {
        settings: Settings;
        activeChannelId: string | null;
    };
    actions: {
        showToast: {
            title: string;
            body: string;
        };
        playSound: "beep";
    };
}, never>({ eventevent: {
    readonly name: "new-message";
    readonly payload: Message;
}, conditionsconditions: ConditionsCtx<{
    settings: Settings;
    activeChannelId: string | null;
}, never>, actionsactions: ActionsCtx<{
    showToast: {
        title: string;
        body: string;
    };
    playSound: "beep";
}>, checkcheck: CheckCtx<{
    settings: Settings;
    activeChannelId: string | null;
}> }) {
    if (eventevent: {
    readonly name: "new-message";
    readonly payload: Message;
}.payloadpayload: Message.channelIdchannelId: string === conditionsconditions: ConditionsCtx<{
    settings: Settings;
    activeChannelId: string | null;
}, never>.activeChannelIdactiveChannelId?: string | null | undefined) return;
    if (!checkcheck: CheckCtx<{
    settings: Settings;
    activeChannelId: string | null;
}>.isis<"settings">(key: "settings", predicate: (value: Settings) => boolean): boolean('settings', ss: Settings => ss: Settings.notificationsnotifications: boolean)) return;

    actionsactions: ActionsCtx<{
    showToast: {
        title: string;
        body: string;
    };
    playSound: "beep";
}>.debouncefunction debounce(ms: number): ActionsCtx<{
    showToast: {
        title: string;
        body: string;
    };
    playSound: "beep";
}>(800).playSoundplaySound?: ((payload: "beep") => void) | undefined?.('beep');
    actionsactions: ActionsCtx<{
    showToast: {
        title: string;
        body: string;
    };
    playSound: "beep";
}>.showToastshowToast?: ((payload: {
    title: string;
    body: string;
}) => void) | undefined?.({
      titletitle: string: eventevent: {
    readonly name: "new-message";
    readonly payload: Message;
}.payloadpayload: Message.authorauthor: string,
      bodybody: string:  eventevent: {
    readonly name: "new-message";
    readonly payload: Message;
}.payloadpayload: Message.texttext: string,
    });
  },
});

Асинхронный обработчик с AbortSignal

import { createTriggerfunction createTrigger<S extends TriggerSchema>(config: CreateTriggerConfig<S>, runtime?: Runtime): Trigger<S>Create a trigger and register it in a runtime (the default runtime if none is passed).
@example```ts
const messageTrigger = createTrigger<{
  events: { 'new-message': { author: string; text: string } };
  conditions: { user: { id: string }; settings: { sound: boolean } };
  actions: { showToast: { title: string }; playSound: void };
}>({
  id: 'message-received',
  events: ['new-message'],
  required: ['user', 'settings'],
  handler({ event, conditions, actions, check }) {
    if (!conditions.user || !conditions.settings) return; // V1: manual narrowing
    if (check.is('settings', (s) => s.sound)) actions.playSound?.();
    actions.showToast?.({ title: event.payload.author });
  },
});
``` } from '@triggery/core';

const fetchTriggerconst fetchTrigger: Trigger<{
    events: {
        "fetch-user": string;
    };
    actions: {
        setUser: {
            id: string;
            name: string;
        };
    };
}> = createTriggercreateTrigger<{
    events: {
        "fetch-user": string;
    };
    actions: {
        setUser: {
            id: string;
            name: string;
        };
    };
}>(config: CreateTriggerConfig<{
    events: {
        "fetch-user": string;
    };
    actions: {
        setUser: {
            id: string;
            name: string;
        };
    };
}>, runtime?: Runtime): Trigger<{
    events: {
        "fetch-user": string;
    };
    actions: {
        setUser: {
            id: string;
            name: string;
        };
    };
}>Create a trigger and register it in a runtime (the default runtime if none is passed).
@example```ts
const messageTrigger = createTrigger<{
  events: { 'new-message': { author: string; text: string } };
  conditions: { user: { id: string }; settings: { sound: boolean } };
  actions: { showToast: { title: string }; playSound: void };
}>({
  id: 'message-received',
  events: ['new-message'],
  required: ['user', 'settings'],
  handler({ event, conditions, actions, check }) {
    if (!conditions.user || !conditions.settings) return; // V1: manual narrowing
    if (check.is('settings', (s) => s.sound)) actions.playSound?.();
    actions.showToast?.({ title: event.payload.author });
  },
});
```<{
  eventsevents: {
    'fetch-user': string;
}:  { 'fetch-user': string };
  actionsactions: {
    setUser: {
        id: string;
        name: string;
    };
}: { setUsersetUser: {
    id: string;
    name: string;
}: { idid: string: string; namename: string: string } };
}>({
  idid: string: 'fetch-user',
  eventsevents: readonly "fetch-user"[]: ['fetch-user'],
  concurrencyconcurrency?: ConcurrencyStrategy | undefinedConcurrency strategy applied across handler runs (default: `'take-latest'`).

- `take-latest` — new run aborts the previous (`signal.aborted` becomes true).
- `take-every`  — every run proceeds independently, no aborts.
- `take-first` / `exhaust` — new runs are skipped while one is still in flight.
- `queue`       — new runs wait for the previous to finish (serialized).
- `sync`        — like `take-every`; provided as a documentation marker.: 'take-latest',
  async handlerhandler: TriggerHandler<{
    events: {
        "fetch-user": string;
    };
    actions: {
        setUser: {
            id: string;
            name: string;
        };
    };
}, never>({ eventevent: {
    readonly name: "fetch-user";
    readonly payload: string;
}, actionsactions: ActionsCtx<{
    setUser: {
        id: string;
        name: string;
    };
}>, signalsignal: AbortSignal }) {
    const resconst res: Response = await fetchfunction fetch(input: string | URL | Request, init?: RequestInit): Promise<Response> (+1 overload)[MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/fetch)(`/api/users/${eventevent: {
    readonly name: "fetch-user";
    readonly payload: string;
}.payloadpayload: string}`, { signalRequestInit.signal?: AbortSignal | null | undefinedAn AbortSignal to set request's signal. });
    if (signalsignal: AbortSignal.abortedAbortSignal.aborted: booleanThe **`aborted`** read-only property returns a value that indicates whether the asynchronous operations the signal is communicating with are aborted (`true`) or not (`false`).

[MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/aborted)) return;
    actionsactions: ActionsCtx<{
    setUser: {
        id: string;
        name: string;
    };
}>.setUsersetUser?: ((payload: {
    id: string;
    name: string;
}) => void) | undefined?.(await resconst res: Response.jsonBody.json(): Promise<any>[MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/json)());
  },
});

Регистрация в конкретном рантайме

import { createRuntimefunction createRuntime(options?: RuntimeOptions): Runtime, createTriggerfunction createTrigger<S extends TriggerSchema>(config: CreateTriggerConfig<S>, runtime?: Runtime): Trigger<S>Create a trigger and register it in a runtime (the default runtime if none is passed).
@example```ts
const messageTrigger = createTrigger<{
  events: { 'new-message': { author: string; text: string } };
  conditions: { user: { id: string }; settings: { sound: boolean } };
  actions: { showToast: { title: string }; playSound: void };
}>({
  id: 'message-received',
  events: ['new-message'],
  required: ['user', 'settings'],
  handler({ event, conditions, actions, check }) {
    if (!conditions.user || !conditions.settings) return; // V1: manual narrowing
    if (check.is('settings', (s) => s.sound)) actions.playSound?.();
    actions.showToast?.({ title: event.payload.author });
  },
});
``` } from '@triggery/core';

const runtimeconst runtime: Runtime = createRuntimefunction createRuntime(options?: RuntimeOptions): Runtime({ inspectorinspector?: InspectorOption | undefinedEnable / disable the per-run inspector. See 
{@link 
InspectorOption
}
.: { devdev?: boolean | undefined: true, prodprod?: boolean | undefined: false } });

const triggerconst trigger: Trigger<{
    events: {
        hi: void;
    };
}> = createTriggercreateTrigger<{
    events: {
        hi: void;
    };
}>(config: CreateTriggerConfig<{
    events: {
        hi: void;
    };
}>, runtime?: Runtime): Trigger<{
    events: {
        hi: void;
    };
}>Create a trigger and register it in a runtime (the default runtime if none is passed).
@example```ts
const messageTrigger = createTrigger<{
  events: { 'new-message': { author: string; text: string } };
  conditions: { user: { id: string }; settings: { sound: boolean } };
  actions: { showToast: { title: string }; playSound: void };
}>({
  id: 'message-received',
  events: ['new-message'],
  required: ['user', 'settings'],
  handler({ event, conditions, actions, check }) {
    if (!conditions.user || !conditions.settings) return; // V1: manual narrowing
    if (check.is('settings', (s) => s.sound)) actions.playSound?.();
    actions.showToast?.({ title: event.payload.author });
  },
});
```<{ eventsevents: {
    hi: void;
}: { hihi: void: void } }>(
  {
    idid: string: 'demo:hi',
    eventsevents: readonly "hi"[]: ['hi'],
    handlerhandler: TriggerHandler<{
    events: {
        hi: void;
    };
}, never>() {
      consolevar console: Console.logConsole.log(...data: any[]): voidThe **`console.log()`** static method outputs a message to the console.

[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)('hi');
    },
  },
  runtimeconst runtime: Runtime,
);

Замечания

См. также

createRuntime Контейнер, в котором живут триггеры, условия и действия.

TriggerSchema Общий тип — карты events / conditions / actions.

TriggerHandler Тип функции аргумента-обработчика.

Руководство по анатомии триггера Пошаговый разбор полей в нарративной форме.