foldkit 0.161.0 → 0.162.0

package/dist/subscription/{keyboardShortcuts.d.ts → keyBindings.d.ts}

@@ -1,41 +1,41 @@
 import { Duration, Stream } from 'effect';
-/** Whether a shortcut may fire when its keyboard event comes from an editable element. */
+/** Whether a key binding may fire when its event comes from an editable element. */
 export type WhileTyping = 'Suppress' | 'Allow';
 /** A single key press or a sequence of two or more key presses. */
-export type KeyboardShortcut = string | Readonly<[string, string, ...Array<string>]>;
+export type KeySequence = string | Readonly<[string, string, ...Array<string>]>;
 type BindingBase<Message> = Readonly<{
-    shortcut: KeyboardShortcut;
+    keys: KeySequence;
     toMessage: (event: KeyboardEvent) => Message;
     isEnabled?: boolean;
     whileTyping?: WhileTyping;
     preventDefault?: boolean;
 }>;
 /**
- * One entry in a {@link keyboardShortcuts} binding table.
+ * One entry in a {@link keyBindings} binding table.
  *
  * A string describes one key press, such as `'/'`, `'Escape'`, or `'Mod+K'`.
  * An array describes a sequence of at least two presses, such as
  * `['G', 'H']` or `['G', 'Shift+G']`.
  */
-export type KeyboardShortcutBinding<Message> = BindingBase<Message> & (Readonly<{
-    shortcut: string;
+export type KeyBinding<Message> = BindingBase<Message> & (Readonly<{
+    keys: string;
     whenRepeated?: 'Ignore' | 'Allow';
 }> | Readonly<{
-    shortcut: Readonly<[string, string, ...Array<string>]>;
+    keys: Readonly<[string, string, ...Array<string>]>;
     whenRepeated?: never;
 }>);
 type ModKey = 'Control' | 'Meta';
-/** Configuration for the {@link keyboardShortcuts} Stream helper. */
-export type KeyboardShortcutsConfig<Message> = Readonly<{
-    bindings: ReadonlyArray<KeyboardShortcutBinding<Message>>;
+/** Configuration for the {@link keyBindings} Stream helper. */
+export type KeyBindingsConfig<Message> = Readonly<{
+    bindings: ReadonlyArray<KeyBinding<Message>>;
     target?: EventTarget | (() => EventTarget);
     modKey?: ModKey;
     sequenceTimeout?: Duration.Input;
 }>;
 /**
- * Build a Stream that turns declarative keyboard shortcuts into Messages.
+ * Build a Stream that turns declarative key bindings into Messages.
  *
- * A string shortcut describes one key press. Modifiers are joined with `+`:
+ * A string describes one key press. Modifiers are joined with `+`:
  * `'Mod+K'`, `'Control+Shift+P'`, or `'Alt+ArrowDown'`. The supported modifiers
  * are `Mod`, `Control`, `Meta`, `Alt`, and `Shift`. `Mod` resolves to Meta on
  * Apple platforms and Control elsewhere; `modKey` can override that choice.
@@ -47,17 +47,17 @@ export type KeyboardShortcutsConfig<Message> = Readonly<{
  * one second by default; `sequenceTimeout` accepts any Effect Duration input.
  * Modifier-only events and repeated keydowns do not advance a sequence.
  *
- * Shortcuts are suppressed by default when the event's composed path contains
+ * Bindings are suppressed by default when the event's composed path contains
  * an `input`, `textarea`, `select`, or contenteditable element. Set
  * `whileTyping` to `'Allow'` for a binding that must work there. Events emitted
  * during IME composition are always ignored. Repeated keydowns are ignored for
- * one-press shortcuts unless `whenRepeated` is `'Allow'`. An event another
+ * one-press bindings unless `whenRepeated` is `'Allow'`. An event another
  * handler already canceled is ignored and clears any sequence in progress.
  *
  * Matched key presses call `preventDefault()` before dispatching. For a
  * sequence, that policy applies to every matched press. Set `preventDefault`
  * to `false` to opt out. Sequences sharing a prefix must use the same policy.
- * Duplicate bindings and a complete shortcut that is also a sequence prefix
+ * Duplicate bindings and a complete binding that is also a sequence prefix
  * are rejected when the Stream is created.
  *
  * This helper returns a Stream, not a complete Subscription entry. Use
@@ -66,7 +66,7 @@ export type KeyboardShortcutsConfig<Message> = Readonly<{
  * derive each binding's `isEnabled` from the dependency record. A dependency
  * change opens a new Stream scope and resets any sequence in progress. If a
  * parent owns a condition for a lifted child, declare the table at that parent
- * or put shortcuts with different parent-owned lifetimes in separate child
+ * or put bindings with different parent-owned lifetimes in separate child
  * entries so `Subscription.lift` can gate them individually. If the meaning
  * of a key depends on the Model, dispatch a factual key Message and decide
  * what it means in update instead of reading the Model from `toMessage`.
@@ -74,28 +74,28 @@ export type KeyboardShortcutsConfig<Message> = Readonly<{
  * @example
  * ```typescript
  * const subscriptions = Subscription.make<Model, Message>()(entry => ({
- *   shortcuts: entry(
+ *   keyBindings: entry(
  *     { isPaletteOpen: Schema.Boolean },
  *     {
  *       modelToDependencies: model => ({
  *         isPaletteOpen: model.paletteState._tag === 'Open',
  *       }),
  *       dependenciesToStream: ({ isPaletteOpen }) =>
- *         Subscription.keyboardShortcuts<Message>({
+ *         Subscription.keyBindings<Message>({
  *           bindings: [
  *             {
- *               shortcut: 'Escape',
+ *               keys: 'Escape',
  *               isEnabled: isPaletteOpen,
  *               whileTyping: 'Allow',
  *               toMessage: () => Message.PressedEscape(),
  *             },
  *             {
- *               shortcut: 'Mod+K',
+ *               keys: 'Mod+K',
  *               whileTyping: 'Allow',
  *               toMessage: () => Message.PressedSearchShortcut(),
  *             },
  *             {
- *               shortcut: ['G', 'L'],
+ *               keys: ['G', 'L'],
  *               toMessage: () => Message.PressedListShortcut(),
  *             },
  *           ],
@@ -105,6 +105,6 @@ export type KeyboardShortcutsConfig<Message> = Readonly<{
  * }))
  * ```
  */
-export declare const keyboardShortcuts: <Message>(config: KeyboardShortcutsConfig<Message>) => Stream.Stream<Message>;
+export declare const keyBindings: <Message>(config: KeyBindingsConfig<Message>) => Stream.Stream<Message>;
 export {};
-//# sourceMappingURL=keyboardShortcuts.d.ts.map
+//# sourceMappingURL=keyBindings.d.ts.map

package/dist/subscription/keyBindings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyBindings.d.ts","sourceRoot":"","sources":["../../src/subscription/keyBindings.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAOR,MAAM,EAGP,MAAM,QAAQ,CAAA;AAEf,oFAAoF;AACpF,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,OAAO,CAAA;AAE9C,mEAAmE;AACnE,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;AAE/E,KAAK,WAAW,CAAC,OAAO,IAAI,QAAQ,CAAC;IACnC,IAAI,EAAE,WAAW,CAAA;IACjB,SAAS,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,OAAO,CAAA;IAC5C,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,cAAc,CAAC,EAAE,OAAO,CAAA;CACzB,CAAC,CAAA;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,CAAC,OAAO,IAAI,WAAW,CAAC,OAAO,CAAC,GACpD,CACI,QAAQ,CAAC;IACP,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAA;CAClC,CAAC,GACF,QAAQ,CAAC;IACP,IAAI,EAAE,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;IAClD,YAAY,CAAC,EAAE,KAAK,CAAA;CACrB,CAAC,CACL,CAAA;AAEH,KAAK,MAAM,GAAG,SAAS,GAAG,MAAM,CAAA;AAEhC,+DAA+D;AAC/D,MAAM,MAAM,iBAAiB,CAAC,OAAO,IAAI,QAAQ,CAAC;IAChD,QAAQ,EAAE,aAAa,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAA;IAC5C,MAAM,CAAC,EAAE,WAAW,GAAG,CAAC,MAAM,WAAW,CAAC,CAAA;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,eAAe,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAA;CACjC,CAAC,CAAA;AA2sBF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,UACzB,iBAAiB,CAAC,OAAO,CAAC,KACjC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAuD,CAAA"}

package/dist/subscription/{keyboardShortcuts.js → keyBindings.js}

@@ -18,7 +18,7 @@ const MODIFIER_KEYS = [
     'symbol',
     'symbollock',
 ];
-const SHORTCUT_MODIFIERS = [
+const BINDING_MODIFIERS = [
     'alt',
     'control',
     'meta',
@@ -53,37 +53,37 @@ const pressIdentifier = (press, modKey) => {
         Option.some(displayKey(press.key)),
     ], Array.getSomes, Array.join('+'));
 };
-const throwInvalidShortcut = (shortcut, reason) => {
-    throw new Error(`Invalid keyboard shortcut "${shortcut}": ${reason}`);
+const throwInvalidKeyPress = (keyPress, reason) => {
+    throw new Error(`Invalid key binding "${keyPress}": ${reason}`);
 };
 const hasDuplicateModifiers = (modifiers) => Array.length(Array.dedupe(modifiers)) !== Array.length(modifiers);
-const parsePress = (shortcut) => {
-    const tokens = pipe(shortcut, String.split('+'), Array.map(token => pipe(token, String.trim, String.toLowerCase)));
+const parsePress = (keyPress) => {
+    const tokens = pipe(keyPress, String.split('+'), Array.map(token => pipe(token, String.trim, String.toLowerCase)));
     if (Array.some(tokens, String.isEmpty)) {
-        return throwInvalidShortcut(shortcut, 'each modifier and key must be named; use "Plus" for the + key');
+        return throwInvalidKeyPress(keyPress, 'each modifier and key must be named; use "Plus" for the + key');
     }
     const maybeNonCanonicalModifier = Array.findFirst(tokens, token => Array.contains(NON_CANONICAL_MODIFIERS, token));
     if (Option.isSome(maybeNonCanonicalModifier)) {
-        return throwInvalidShortcut(shortcut, `unknown modifier "${maybeNonCanonicalModifier.value}"`);
+        return throwInvalidKeyPress(keyPress, `unknown modifier "${maybeNonCanonicalModifier.value}"`);
     }
     const [modifiers, keyToken] = Array.unappend(tokens);
     const key = normalizeKey(keyToken);
-    if (Array.contains(SHORTCUT_MODIFIERS, keyToken) ||
+    if (Array.contains(BINDING_MODIFIERS, keyToken) ||
         Array.contains(MODIFIER_KEYS, key)) {
-        return throwInvalidShortcut(shortcut, 'a non-modifier key is required');
+        return throwInvalidKeyPress(keyPress, 'a non-modifier key is required');
     }
-    const maybeUnknownModifier = Array.findFirst(modifiers, modifier => !Array.contains(SHORTCUT_MODIFIERS, modifier));
+    const maybeUnknownModifier = Array.findFirst(modifiers, modifier => !Array.contains(BINDING_MODIFIERS, modifier));
     if (Option.isSome(maybeUnknownModifier)) {
-        return throwInvalidShortcut(shortcut, `unknown modifier "${maybeUnknownModifier.value}"`);
+        return throwInvalidKeyPress(keyPress, `unknown modifier "${maybeUnknownModifier.value}"`);
     }
     if (hasDuplicateModifiers(modifiers)) {
-        return throwInvalidShortcut(shortcut, 'a modifier is repeated');
+        return throwInvalidKeyPress(keyPress, 'a modifier is repeated');
     }
     const isModRequired = Array.contains(modifiers, 'mod');
     const isControlRequired = Array.contains(modifiers, 'control');
     const isMetaRequired = Array.contains(modifiers, 'meta');
     if (isModRequired && (isControlRequired || isMetaRequired)) {
-        return throwInvalidShortcut(shortcut, 'Mod cannot be combined with Control or Meta');
+        return throwInvalidKeyPress(keyPress, 'Mod cannot be combined with Control or Meta');
     }
     const isAltRequired = Array.contains(modifiers, 'alt');
     const isShiftRequired = Array.contains(modifiers, 'shift');
@@ -101,13 +101,12 @@ const parsePress = (shortcut) => {
     };
 };
 const compileBinding = (binding) => {
-    if (!Predicate.isString(binding.shortcut) &&
-        Array.length(binding.shortcut) < 2) {
-        throw new Error('A keyboard shortcut sequence requires at least two keys');
+    if (!Predicate.isString(binding.keys) && Array.length(binding.keys) < 2) {
+        throw new Error('A key binding sequence requires at least two key presses');
     }
-    const presses = Predicate.isString(binding.shortcut)
-        ? Array.of(parsePress(binding.shortcut))
-        : Array.map(binding.shortcut, parsePress);
+    const presses = Predicate.isString(binding.keys)
+        ? Array.of(parsePress(binding.keys))
+        : Array.map(binding.keys, parsePress);
     return {
         presses,
         toMessage: binding.toMessage,
@@ -131,12 +130,12 @@ const validateBindingPair = (binding, otherBinding, modKey) => {
     if (bindingIsPrefix || otherBindingIsPrefix) {
         const relation = Array.length(binding.presses) === Array.length(otherBinding.presses)
             ? 'duplicates'
-            : 'overlaps as a complete shortcut and a sequence prefix';
-        throw new Error(`Keyboard shortcut "${bindingLabel(binding)}" ${relation} "${bindingLabel(otherBinding)}"`);
+            : 'overlaps as a complete binding and a sequence prefix';
+        throw new Error(`Key binding "${bindingLabel(binding)}" ${relation} "${bindingLabel(otherBinding)}"`);
     }
     if (sharesFirstPress(binding, otherBinding, modKey) &&
         binding.preventDefault !== otherBinding.preventDefault) {
-        throw new Error(`Keyboard shortcut sequences beginning with the same key must use the same preventDefault setting: "${bindingLabel(binding)}" and "${bindingLabel(otherBinding)}"`);
+        throw new Error(`Key binding sequences beginning with the same key must use the same preventDefault setting: "${bindingLabel(binding)}" and "${bindingLabel(otherBinding)}"`);
     }
 };
 const validateBindings = (bindings, modKey) => {
@@ -193,7 +192,7 @@ const resolveValidationModKey = (configuredModKey) => {
     }
     return Option.some(resolveModKey(undefined));
 };
-const compileKeyboardShortcutsConfig = (config) => {
+const compileKeyBindingsConfig = (config) => {
     const bindings = compileEnabledBindings(config.bindings);
     const sequenceTimeout = Duration.toMillis(config.sequenceTimeout ?? DEFAULT_SEQUENCE_TIMEOUT);
     if (!globalThis.Number.isFinite(sequenceTimeout) || sequenceTimeout <= 0) {
@@ -292,7 +291,7 @@ const continueSequence = (context, sequence, event) => {
         event.preventDefault();
     }
 };
-const handleKeyboardShortcutEvent = (context, event) => {
+const handleKeyBindingEvent = (context, event) => {
     if (!(event instanceof KeyboardEvent)) {
         return;
     }
@@ -312,7 +311,7 @@ const handleKeyboardShortcutEvent = (context, event) => {
         onSome: sequence => continueSequence(context, sequence, event),
     });
 };
-const makeKeyboardShortcutHandler = (config) => {
+const makeKeyBindingHandler = (config) => {
     const sequenceController = makeSequenceController(config.sequenceTimeout);
     const context = {
         bindings: config.bindings,
@@ -322,7 +321,7 @@ const makeKeyboardShortcutHandler = (config) => {
     };
     return {
         clearSequence: sequenceController.clearSequence,
-        handleEvent: event => handleKeyboardShortcutEvent(context, event),
+        handleEvent: event => handleKeyBindingEvent(context, event),
     };
 };
 const resolveOwnerDocument = (target) => {
@@ -334,11 +333,11 @@ const resolveOwnerDocument = (target) => {
     }
     return document;
 };
-const acquireKeyboardShortcutListener = (config, emitMessage) => {
+const acquireKeyBindingListener = (config, emitMessage) => {
     const target = resolveTarget(config.target);
     const modKey = resolveModKey(config.modKey);
     validateBindings(config.bindings, modKey);
-    const handler = makeKeyboardShortcutHandler({
+    const handler = makeKeyBindingHandler({
         bindings: config.bindings,
         emitMessage,
         modKey,
@@ -356,22 +355,22 @@ const acquireKeyboardShortcutListener = (config, emitMessage) => {
         target,
     };
 };
-const releaseKeyboardShortcutListener = (listener) => {
+const releaseKeyBindingListener = (listener) => {
     listener.target.removeEventListener('keydown', listener.handleEvent);
     listener.ownerWindow.removeEventListener('blur', listener.clearSequence);
     listener.ownerDocument.removeEventListener('visibilitychange', listener.clearSequence);
     listener.clearSequence();
 };
-const keyboardShortcutStream = (config) => Stream.callback(queue => {
+const keyBindingStream = (config) => Stream.callback(queue => {
     const emitMessage = (message) => {
         Queue.offerUnsafe(queue, message);
     };
-    return Effect.acquireRelease(Effect.sync(() => acquireKeyboardShortcutListener(config, emitMessage)), listener => Effect.sync(() => releaseKeyboardShortcutListener(listener)));
+    return Effect.acquireRelease(Effect.sync(() => acquireKeyBindingListener(config, emitMessage)), listener => Effect.sync(() => releaseKeyBindingListener(listener)));
 });
 /**
- * Build a Stream that turns declarative keyboard shortcuts into Messages.
+ * Build a Stream that turns declarative key bindings into Messages.
  *
- * A string shortcut describes one key press. Modifiers are joined with `+`:
+ * A string describes one key press. Modifiers are joined with `+`:
  * `'Mod+K'`, `'Control+Shift+P'`, or `'Alt+ArrowDown'`. The supported modifiers
  * are `Mod`, `Control`, `Meta`, `Alt`, and `Shift`. `Mod` resolves to Meta on
  * Apple platforms and Control elsewhere; `modKey` can override that choice.
@@ -383,17 +382,17 @@ const keyboardShortcutStream = (config) => Stream.callback(queue => {
  * one second by default; `sequenceTimeout` accepts any Effect Duration input.
  * Modifier-only events and repeated keydowns do not advance a sequence.
  *
- * Shortcuts are suppressed by default when the event's composed path contains
+ * Bindings are suppressed by default when the event's composed path contains
  * an `input`, `textarea`, `select`, or contenteditable element. Set
  * `whileTyping` to `'Allow'` for a binding that must work there. Events emitted
  * during IME composition are always ignored. Repeated keydowns are ignored for
- * one-press shortcuts unless `whenRepeated` is `'Allow'`. An event another
+ * one-press bindings unless `whenRepeated` is `'Allow'`. An event another
  * handler already canceled is ignored and clears any sequence in progress.
  *
  * Matched key presses call `preventDefault()` before dispatching. For a
  * sequence, that policy applies to every matched press. Set `preventDefault`
  * to `false` to opt out. Sequences sharing a prefix must use the same policy.
- * Duplicate bindings and a complete shortcut that is also a sequence prefix
+ * Duplicate bindings and a complete binding that is also a sequence prefix
  * are rejected when the Stream is created.
  *
  * This helper returns a Stream, not a complete Subscription entry. Use
@@ -402,7 +401,7 @@ const keyboardShortcutStream = (config) => Stream.callback(queue => {
  * derive each binding's `isEnabled` from the dependency record. A dependency
  * change opens a new Stream scope and resets any sequence in progress. If a
  * parent owns a condition for a lifted child, declare the table at that parent
- * or put shortcuts with different parent-owned lifetimes in separate child
+ * or put bindings with different parent-owned lifetimes in separate child
  * entries so `Subscription.lift` can gate them individually. If the meaning
  * of a key depends on the Model, dispatch a factual key Message and decide
  * what it means in update instead of reading the Model from `toMessage`.
@@ -410,28 +409,28 @@ const keyboardShortcutStream = (config) => Stream.callback(queue => {
  * @example
  * ```typescript
  * const subscriptions = Subscription.make<Model, Message>()(entry => ({
- *   shortcuts: entry(
+ *   keyBindings: entry(
  *     { isPaletteOpen: Schema.Boolean },
  *     {
  *       modelToDependencies: model => ({
  *         isPaletteOpen: model.paletteState._tag === 'Open',
  *       }),
  *       dependenciesToStream: ({ isPaletteOpen }) =>
- *         Subscription.keyboardShortcuts<Message>({
+ *         Subscription.keyBindings<Message>({
  *           bindings: [
  *             {
- *               shortcut: 'Escape',
+ *               keys: 'Escape',
  *               isEnabled: isPaletteOpen,
  *               whileTyping: 'Allow',
  *               toMessage: () => Message.PressedEscape(),
  *             },
  *             {
- *               shortcut: 'Mod+K',
+ *               keys: 'Mod+K',
  *               whileTyping: 'Allow',
  *               toMessage: () => Message.PressedSearchShortcut(),
  *             },
  *             {
- *               shortcut: ['G', 'L'],
+ *               keys: ['G', 'L'],
  *               toMessage: () => Message.PressedListShortcut(),
  *             },
  *           ],
@@ -441,4 +440,4 @@ const keyboardShortcutStream = (config) => Stream.callback(queue => {
  * }))
  * ```
  */
-export const keyboardShortcuts = (config) => keyboardShortcutStream(compileKeyboardShortcutsConfig(config));
+export const keyBindings = (config) => keyBindingStream(compileKeyBindingsConfig(config));

package/dist/subscription/public.d.ts

@@ -4,6 +4,6 @@ export { animationFrame } from './animationFrame.js';
 export type { AnimationFrameConfig } from './animationFrame.js';
 export { fromEvent, fromEventFilterMap, fromEventFilterMapPreventDefault, } from './fromEvent.js';
 export type { FromEventConfig, FromEventFilterMapConfig, FromEventFilterMapPreventDefaultConfig, TypedEventTarget, } from './fromEvent.js';
-export { keyboardShortcuts } from './keyboardShortcuts.js';
-export type { KeyboardShortcut, KeyboardShortcutBinding, KeyboardShortcutsConfig, WhileTyping, } from './keyboardShortcuts.js';
+export { keyBindings } from './keyBindings.js';
+export type { KeyBinding, KeyBindingsConfig, KeySequence, WhileTyping, } from './keyBindings.js';
 //# sourceMappingURL=public.d.ts.map

package/dist/subscription/public.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../src/subscription/public.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAErE,YAAY,EACV,qBAAqB,EACrB,iBAAiB,EACjB,YAAY,EACZ,aAAa,GACd,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAEpD,YAAY,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAA;AAE/D,OAAO,EACL,SAAS,EACT,kBAAkB,EAClB,gCAAgC,GACjC,MAAM,gBAAgB,CAAA;AAEvB,YAAY,EACV,eAAe,EACf,wBAAwB,EACxB,sCAAsC,EACtC,gBAAgB,GACjB,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAE1D,YAAY,EACV,gBAAgB,EAChB,uBAAuB,EACvB,uBAAuB,EACvB,WAAW,GACZ,MAAM,wBAAwB,CAAA"}
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../src/subscription/public.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAErE,YAAY,EACV,qBAAqB,EACrB,iBAAiB,EACjB,YAAY,EACZ,aAAa,GACd,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAEpD,YAAY,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAA;AAE/D,OAAO,EACL,SAAS,EACT,kBAAkB,EAClB,gCAAgC,GACjC,MAAM,gBAAgB,CAAA;AAEvB,YAAY,EACV,eAAe,EACf,wBAAwB,EACxB,sCAAsC,EACtC,gBAAgB,GACjB,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAE9C,YAAY,EACV,UAAU,EACV,iBAAiB,EACjB,WAAW,EACX,WAAW,GACZ,MAAM,kBAAkB,CAAA"}

package/dist/subscription/public.js

@@ -1,4 +1,4 @@
 export { aggregate, lift, make, persistent } from './subscription.js';
 export { animationFrame } from './animationFrame.js';
 export { fromEvent, fromEventFilterMap, fromEventFilterMapPreventDefault, } from './fromEvent.js';
-export { keyboardShortcuts } from './keyboardShortcuts.js';
+export { keyBindings } from './keyBindings.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foldkit",
-  "version": "0.161.0",
+  "version": "0.162.0",
   "description": "A TypeScript frontend framework, built on Effect and architected like Elm",
   "type": "module",
   "main": "./dist/index.js",

package/dist/subscription/keyboardShortcuts.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"keyboardShortcuts.d.ts","sourceRoot":"","sources":["../../src/subscription/keyboardShortcuts.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAOR,MAAM,EAGP,MAAM,QAAQ,CAAA;AAEf,0FAA0F;AAC1F,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,OAAO,CAAA;AAE9C,mEAAmE;AACnE,MAAM,MAAM,gBAAgB,GACxB,MAAM,GACN,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;AAEhD,KAAK,WAAW,CAAC,OAAO,IAAI,QAAQ,CAAC;IACnC,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,SAAS,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,OAAO,CAAA;IAC5C,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,cAAc,CAAC,EAAE,OAAO,CAAA;CACzB,CAAC,CAAA;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,uBAAuB,CAAC,OAAO,IAAI,WAAW,CAAC,OAAO,CAAC,GACjE,CACI,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAA;CAClC,CAAC,GACF,QAAQ,CAAC;IACP,QAAQ,EAAE,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;IACtD,YAAY,CAAC,EAAE,KAAK,CAAA;CACrB,CAAC,CACL,CAAA;AAEH,KAAK,MAAM,GAAG,SAAS,GAAG,MAAM,CAAA;AAEhC,qEAAqE;AACrE,MAAM,MAAM,uBAAuB,CAAC,OAAO,IAAI,QAAQ,CAAC;IACtD,QAAQ,EAAE,aAAa,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAC,CAAA;IACzD,MAAM,CAAC,EAAE,WAAW,GAAG,CAAC,MAAM,WAAW,CAAC,CAAA;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,eAAe,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAA;CACjC,CAAC,CAAA;AA8sBF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,UAC/B,uBAAuB,CAAC,OAAO,CAAC,KACvC,MAAM,CAAC,MAAM,CAAC,OAAO,CACwC,CAAA"}