foldkit-mixins 0.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +222 -0
- package/dist/index.d.mts +543 -0
- package/dist/index.d.mts.map +1 -0
- package/dist/index.mjs +1171 -0
- package/dist/index.mjs.map +1 -0
- package/dist/rolldown-runtime-D7D4PA-g.mjs +13 -0
- package/package.json +43 -0
package/dist/index.d.mts
ADDED
|
@@ -0,0 +1,543 @@
|
|
|
1
|
+
import { Attribute, ChildAttribute, Html, HtmlBuilder } from "foldkit/html";
|
|
2
|
+
import { MountAction } from "foldkit/mount";
|
|
3
|
+
declare namespace diagnostics_d_exports {
|
|
4
|
+
export { Diagnostic, DiagnosticCode, DiagnosticError };
|
|
5
|
+
}
|
|
6
|
+
/**
|
|
7
|
+
* Structured diagnostics for attachment conflicts. Codes are stable so tests,
|
|
8
|
+
* DevTools, and editor tooling can share them. Resolution failures are
|
|
9
|
+
* programming errors (a definition attaches something a slot does not allow),
|
|
10
|
+
* so `resolve` throws a `DiagnosticError` carrying one.
|
|
11
|
+
*/
|
|
12
|
+
type DiagnosticCode = 'mixins:unknown-slot' | 'mixins:hidden-slot' | 'mixins:capability-mismatch' | 'mixins:unsupported-event' | 'mixins:unsupported-attribute' | 'mixins:protected-event' | 'mixins:protected-attribute' | 'mixins:protected-style-property' | 'mixins:event-conflict' | 'mixins:attribute-conflict' | 'mixins:structural-override' | 'mixins:duplicate-mount-name' | 'style:conditional-rules-unsupported' | 'a11y:missing-slot' | 'a11y:hidden-slot' | 'a11y:capability-mismatch' | 'a11y:missing-event' | 'a11y:missing-attribute';
|
|
13
|
+
interface Diagnostic {
|
|
14
|
+
readonly source: 'mixins' | 'a11y';
|
|
15
|
+
readonly code: DiagnosticCode;
|
|
16
|
+
readonly severity: 'error';
|
|
17
|
+
readonly message: string;
|
|
18
|
+
readonly slot?: string;
|
|
19
|
+
readonly details?: Readonly<Record<string, unknown>>;
|
|
20
|
+
}
|
|
21
|
+
declare class DiagnosticError extends Error {
|
|
22
|
+
readonly diagnostic: Diagnostic;
|
|
23
|
+
constructor(diagnostic: Diagnostic);
|
|
24
|
+
}
|
|
25
|
+
declare namespace metadataToken_d_exports {
|
|
26
|
+
export { Any$2 as Any, KindOf, MetadataToken, MetadataTokenTypeId, NameOf$2 as NameOf, NamesOf$2 as NamesOf, is$5 as is, make$6 as make, nameOf };
|
|
27
|
+
}
|
|
28
|
+
/**
|
|
29
|
+
* Ported from `effect-atom-jsx/src/MetadataToken.ts`. Kinded name tokens so
|
|
30
|
+
* Event, Attr, Requirement, and Capability share one witness instead of four
|
|
31
|
+
* ad-hoc brands.
|
|
32
|
+
*/
|
|
33
|
+
declare const MetadataTokenTypeId: unique symbol;
|
|
34
|
+
interface MetadataToken<Kind extends string, Name extends string> {
|
|
35
|
+
readonly [MetadataTokenTypeId]: {
|
|
36
|
+
readonly Kind: Kind;
|
|
37
|
+
readonly Name: Name;
|
|
38
|
+
};
|
|
39
|
+
readonly kind: Kind;
|
|
40
|
+
readonly name: Name;
|
|
41
|
+
}
|
|
42
|
+
type Any$2 = MetadataToken<string, string>;
|
|
43
|
+
type NameOf$2<T> = T extends MetadataToken<any, infer Name> ? Name : T extends string ? T : never;
|
|
44
|
+
type KindOf<T> = T extends MetadataToken<infer Kind, any> ? Kind : never;
|
|
45
|
+
type NamesOf$2<T extends readonly unknown[]> = NameOf$2<T[number]>;
|
|
46
|
+
declare const make$6: <const Kind extends string, const Name extends string>(kind: Kind, name: Name) => MetadataToken<Kind, Name>;
|
|
47
|
+
declare const is$5: (value: unknown) => value is Any$2;
|
|
48
|
+
declare const nameOf: (value: string | Any$2) => string;
|
|
49
|
+
declare namespace attr_d_exports {
|
|
50
|
+
export { AriaDescribedby, AriaDisabled, AriaExpanded, AriaInvalid, AriaLabel, AriaSelected, AttrToken, Disabled, Role, Value, describe$5 as describe, equals$1 as equals, is$4 as is, make$5 as make };
|
|
51
|
+
}
|
|
52
|
+
type AttrToken<Name extends string = string> = MetadataToken<'view.attribute', Name>;
|
|
53
|
+
declare const is$4: (value: unknown) => value is AttrToken;
|
|
54
|
+
declare const make$5: <const Name extends string>(name: Name) => AttrToken<Name>;
|
|
55
|
+
declare const equals$1: (left: AttrToken, right: AttrToken) => boolean;
|
|
56
|
+
declare const describe$5: (attr: AttrToken) => {
|
|
57
|
+
readonly name: string;
|
|
58
|
+
};
|
|
59
|
+
declare const Role: AttrToken<"role">;
|
|
60
|
+
declare const AriaLabel: AttrToken<"aria-label">;
|
|
61
|
+
declare const AriaDescribedby: AttrToken<"aria-describedby">;
|
|
62
|
+
declare const AriaExpanded: AttrToken<"aria-expanded">;
|
|
63
|
+
declare const AriaSelected: AttrToken<"aria-selected">;
|
|
64
|
+
declare const AriaInvalid: AttrToken<"aria-invalid">;
|
|
65
|
+
declare const AriaDisabled: AttrToken<"aria-disabled">;
|
|
66
|
+
declare const Disabled: AttrToken<"disabled">;
|
|
67
|
+
declare const Value: AttrToken<"value">;
|
|
68
|
+
declare namespace capability_d_exports {
|
|
69
|
+
export { Any, AssignableNamesOf, Base, Capability, CapabilityParent, Collection, Container, Draggable, ExtendsOf, Focusable, Interactive, NameOf$1 as NameOf, NamesOf$1 as NamesOf, Satisfies, TextInput, describe$4 as describe, extendsCapability, is$3 as is, make$4 as make, names, satisfies };
|
|
70
|
+
}
|
|
71
|
+
type CapabilityParent = string | MetadataToken<'element.capability', string>;
|
|
72
|
+
interface Capability<Name extends string = string, Extends extends readonly CapabilityParent[] = readonly []> extends MetadataToken<'element.capability', Name> {
|
|
73
|
+
readonly extends: Extends;
|
|
74
|
+
}
|
|
75
|
+
type Any = Capability<string, readonly CapabilityParent[]>;
|
|
76
|
+
type NameOf$1<T> = NameOf$2<T>;
|
|
77
|
+
type NamesOf$1<T extends readonly unknown[]> = NamesOf$2<T>;
|
|
78
|
+
type ExtendsOf<T> = T extends Capability<any, infer Extends> ? NameOf$2<Extends[number]> : never;
|
|
79
|
+
type AssignableNamesOf<T> = T extends string ? T : T extends Capability<any, infer Extends> ? NameOf$2<T> | AssignableNamesOf<Extends[number]> : NameOf$2<T>;
|
|
80
|
+
type Satisfies<Actual, Required extends {
|
|
81
|
+
readonly name: string;
|
|
82
|
+
}> = Required['name'] extends AssignableNamesOf<Actual> ? true : false;
|
|
83
|
+
declare const is$3: (value: unknown) => value is Any;
|
|
84
|
+
declare const make$4: <const Name extends string, const Extends extends readonly CapabilityParent[] = readonly []>(name: Name, options?: {
|
|
85
|
+
readonly extends?: Extends;
|
|
86
|
+
}) => Capability<Name, Extends>;
|
|
87
|
+
/** True when `value` is `base` or inherits from it. Ported from AF-UI. */
|
|
88
|
+
declare const extendsCapability: (value: string | Any, base: string | Any) => boolean;
|
|
89
|
+
declare const satisfies: (actual: string | Any, required: string | Any) => boolean;
|
|
90
|
+
declare const names: (capability: Any) => ReadonlyArray<string>;
|
|
91
|
+
declare const describe$4: (capability: Any) => {
|
|
92
|
+
readonly name: string;
|
|
93
|
+
readonly extends: ReadonlyArray<string>;
|
|
94
|
+
};
|
|
95
|
+
declare const Base: Capability<"Base", readonly []>;
|
|
96
|
+
declare const Interactive: Capability<"Interactive", readonly [Capability<"Base", readonly []>]>;
|
|
97
|
+
declare const Container: Capability<"Container", readonly [Capability<"Interactive", readonly [Capability<"Base", readonly []>]>]>;
|
|
98
|
+
declare const Focusable: Capability<"Focusable", readonly [Capability<"Interactive", readonly [Capability<"Base", readonly []>]>]>;
|
|
99
|
+
declare const TextInput: Capability<"TextInput", readonly [Capability<"Focusable", readonly [Capability<"Interactive", readonly [Capability<"Base", readonly []>]>]>]>;
|
|
100
|
+
declare const Draggable: Capability<"Draggable", readonly [Capability<"Interactive", readonly [Capability<"Base", readonly []>]>]>;
|
|
101
|
+
declare const Collection: Capability<"Collection", readonly [Capability<"Base", readonly []>]>;
|
|
102
|
+
declare namespace event_d_exports {
|
|
103
|
+
export { Blur, Cancel, Change, Click, EventToken, Focus, Hover, Input, KeyDown, PointerDown, PointerUp, Press, Submit, describe$3 as describe, equals, is$2 as is, make$3 as make };
|
|
104
|
+
}
|
|
105
|
+
type EventToken<Name extends string = string> = MetadataToken<'view.event', Name>;
|
|
106
|
+
declare const is$2: (value: unknown) => value is EventToken;
|
|
107
|
+
declare const make$3: <const Name extends string>(name: Name) => EventToken<Name>;
|
|
108
|
+
declare const equals: (left: EventToken, right: EventToken) => boolean;
|
|
109
|
+
declare const describe$3: (event: EventToken) => {
|
|
110
|
+
readonly name: string;
|
|
111
|
+
};
|
|
112
|
+
declare const Press: EventToken<"press">;
|
|
113
|
+
declare const Click: EventToken<"click">;
|
|
114
|
+
declare const Cancel: EventToken<"cancel">;
|
|
115
|
+
declare const Input: EventToken<"input">;
|
|
116
|
+
declare const Change: EventToken<"change">;
|
|
117
|
+
declare const Focus: EventToken<"focus">;
|
|
118
|
+
declare const Blur: EventToken<"blur">;
|
|
119
|
+
declare const KeyDown: EventToken<"keydown">;
|
|
120
|
+
declare const PointerDown: EventToken<"pointerdown">;
|
|
121
|
+
declare const PointerUp: EventToken<"pointerup">;
|
|
122
|
+
declare const Hover: EventToken<"hover">;
|
|
123
|
+
declare const Submit: EventToken<"submit">;
|
|
124
|
+
//#endregion
|
|
125
|
+
//#region src/pipe.d.ts
|
|
126
|
+
type Pipeable<Self> = {
|
|
127
|
+
pipe(): Self;
|
|
128
|
+
pipe(...fns: ReadonlyArray<(self: Self) => Self>): Self;
|
|
129
|
+
pipe<A>(ab: (self: Self) => A): A;
|
|
130
|
+
pipe<A, B>(ab: (self: Self) => A, bc: (a: A) => B): B;
|
|
131
|
+
pipe<A, B, C>(ab: (self: Self) => A, bc: (a: A) => B, cd: (b: B) => C): C;
|
|
132
|
+
};
|
|
133
|
+
declare namespace requirement_d_exports {
|
|
134
|
+
export { Clipboard, Keyboard, Pointer, RequirementToken, describe$2 as describe, is$1 as is, make$2 as make };
|
|
135
|
+
}
|
|
136
|
+
type RequirementToken<Name extends string = string> = MetadataToken<'view.requirement', Name>;
|
|
137
|
+
declare const is$1: (value: unknown) => value is RequirementToken;
|
|
138
|
+
declare const make$2: <const Name extends string>(name: Name) => RequirementToken<Name>;
|
|
139
|
+
declare const describe$2: (requirement: RequirementToken) => {
|
|
140
|
+
readonly name: string;
|
|
141
|
+
};
|
|
142
|
+
declare const Keyboard: RequirementToken<"keyboard">;
|
|
143
|
+
declare const Pointer: RequirementToken<"pointer">;
|
|
144
|
+
declare const Clipboard: RequirementToken<"clipboard">;
|
|
145
|
+
declare namespace slot_d_exports {
|
|
146
|
+
export { Any$1 as Any, AssignableCapabilityNamesOf, AttributeName, AttributesOf, CapabilityOf, CapabilityValueOf, EventName, EventsOf, Hidden$1 as Hidden, HiddenOf, MakeOptions, NameOf, Public, RequirementName, Slot, SlotCapability, SlotMetadata, SlotProtection, SlotTypeId, UnnamedSlot, attributes, capability, describe$1 as describe, events, hide, is, make$1 as make, requires };
|
|
147
|
+
}
|
|
148
|
+
declare const SlotTypeId: unique symbol;
|
|
149
|
+
type SlotTypeId = typeof SlotTypeId;
|
|
150
|
+
type EventName = string | EventToken;
|
|
151
|
+
type AttributeName = string | AttrToken;
|
|
152
|
+
type RequirementName = string | RequirementToken;
|
|
153
|
+
type SlotCapability = string | Any;
|
|
154
|
+
interface SlotProtection {
|
|
155
|
+
readonly events: ReadonlyArray<EventName>;
|
|
156
|
+
readonly attributes: ReadonlyArray<AttributeName>;
|
|
157
|
+
readonly style: ReadonlyArray<string>;
|
|
158
|
+
}
|
|
159
|
+
interface SlotMetadata<Name extends string = string> {
|
|
160
|
+
readonly name: Name;
|
|
161
|
+
readonly capability: SlotCapability;
|
|
162
|
+
readonly allowedEvents: readonly EventName[];
|
|
163
|
+
readonly allowedAttributes: readonly AttributeName[];
|
|
164
|
+
readonly platformRequirements: readonly RequirementName[];
|
|
165
|
+
readonly hidden: boolean;
|
|
166
|
+
readonly protected: SlotProtection;
|
|
167
|
+
}
|
|
168
|
+
interface Slot<Name extends string = string, C extends SlotCapability = typeof Base, Events extends readonly EventName[] = readonly [], Attributes extends readonly AttributeName[] = readonly [], Requirements extends readonly RequirementName[] = readonly [], Hidden extends boolean = false> extends Pipeable<Slot<Name, C, Events, Attributes, Requirements, Hidden>> {
|
|
169
|
+
readonly [SlotTypeId]: {
|
|
170
|
+
readonly Name: Name;
|
|
171
|
+
readonly Capability: C;
|
|
172
|
+
readonly Events: Events;
|
|
173
|
+
readonly Attributes: Attributes;
|
|
174
|
+
readonly Requirements: Requirements;
|
|
175
|
+
readonly Hidden: Hidden;
|
|
176
|
+
};
|
|
177
|
+
readonly name: Name;
|
|
178
|
+
readonly capability: C;
|
|
179
|
+
readonly events: Events;
|
|
180
|
+
readonly attributes: Attributes;
|
|
181
|
+
readonly requirements: Requirements;
|
|
182
|
+
readonly hidden: Hidden;
|
|
183
|
+
readonly protected: SlotProtection;
|
|
184
|
+
readonly metadata: SlotMetadata<Name> & {
|
|
185
|
+
readonly capability: C;
|
|
186
|
+
readonly allowedEvents: Events;
|
|
187
|
+
readonly allowedAttributes: Attributes;
|
|
188
|
+
readonly platformRequirements: Requirements;
|
|
189
|
+
readonly hidden: Hidden;
|
|
190
|
+
};
|
|
191
|
+
}
|
|
192
|
+
type Any$1 = Slot<string, SlotCapability, readonly EventName[], readonly AttributeName[], readonly RequirementName[], boolean>;
|
|
193
|
+
type UnnamedSlot<C extends SlotCapability = SlotCapability, Events extends readonly EventName[] = readonly EventName[], Attributes extends readonly AttributeName[] = readonly AttributeName[], Requirements extends readonly RequirementName[] = readonly RequirementName[], Hidden extends boolean = boolean> = Omit<Slot<'', C, Events, Attributes, Requirements, Hidden>, 'name'> & {
|
|
194
|
+
readonly name?: never;
|
|
195
|
+
};
|
|
196
|
+
type NameOf<T> = T extends Slot<infer Name, any, any, any, any, any> ? Name : never;
|
|
197
|
+
type CapabilityOf<T> = T extends Slot<any, infer C, any, any, any, any> ? NameOf$2<C> : never;
|
|
198
|
+
type CapabilityValueOf<T> = T extends Slot<any, infer C, any, any, any, any> ? C : never;
|
|
199
|
+
type EventsOf<T> = T extends Slot<any, any, infer Events, any, any, any> ? NamesOf$2<Events> : never;
|
|
200
|
+
type AttributesOf<T> = T extends Slot<any, any, any, infer Attributes, any, any> ? NamesOf$2<Attributes> : never;
|
|
201
|
+
type HiddenOf<T> = T extends Slot<any, any, any, any, any, infer Hidden> ? Hidden : never;
|
|
202
|
+
type AssignableCapabilityNamesOf<T> = AssignableNamesOf<CapabilityValueOf<T>>;
|
|
203
|
+
type Public<T> = HiddenOf<T> extends true ? never : T;
|
|
204
|
+
type Hidden$1<T> = HiddenOf<T> extends true ? T : never;
|
|
205
|
+
declare const is: (value: unknown) => value is Any$1 | UnnamedSlot;
|
|
206
|
+
interface MakeOptions<C extends SlotCapability = SlotCapability, Events extends readonly EventName[] = readonly EventName[], Attributes extends readonly AttributeName[] = readonly AttributeName[], Requirements extends readonly RequirementName[] = readonly RequirementName[], Hidden extends boolean = boolean> {
|
|
207
|
+
readonly capability?: C;
|
|
208
|
+
readonly events?: Events;
|
|
209
|
+
readonly allowedEvents?: Events;
|
|
210
|
+
readonly attributes?: Attributes;
|
|
211
|
+
readonly allowedAttributes?: Attributes;
|
|
212
|
+
readonly requirements?: Requirements;
|
|
213
|
+
readonly platformRequirements?: Requirements;
|
|
214
|
+
readonly hidden?: Hidden;
|
|
215
|
+
readonly protected?: {
|
|
216
|
+
readonly events?: ReadonlyArray<EventName>;
|
|
217
|
+
readonly attributes?: ReadonlyArray<AttributeName>;
|
|
218
|
+
readonly style?: ReadonlyArray<string>;
|
|
219
|
+
};
|
|
220
|
+
}
|
|
221
|
+
/** AF-UI form: name is the first argument. */
|
|
222
|
+
declare function make$1<const Name extends string, const C extends SlotCapability = typeof Base, const Events extends readonly EventName[] = readonly [], const Attributes extends readonly AttributeName[] = readonly [], const Requirements extends readonly RequirementName[] = readonly [], const Hidden extends boolean = false>(name: Name, options?: MakeOptions<C, Events, Attributes, Requirements, Hidden>): Slot<Name, C, Events, Attributes, Requirements, Hidden>;
|
|
223
|
+
/** Foldkit form: name comes from `Slots.define` keys. */
|
|
224
|
+
declare function make$1<const C extends SlotCapability = typeof Base, const Events extends readonly EventName[] = readonly [], const Attributes extends readonly AttributeName[] = readonly [], const Requirements extends readonly RequirementName[] = readonly [], const Hidden extends boolean = false>(options: MakeOptions<C, Events, Attributes, Requirements, Hidden>): UnnamedSlot<C, Events, Attributes, Requirements, Hidden>;
|
|
225
|
+
/** Pipeable transform replacing a named slot's capability. */
|
|
226
|
+
declare const capability: <const C extends SlotCapability>(capability: C) => <Name extends string, OldC extends SlotCapability, Events extends readonly EventName[], Attributes extends readonly AttributeName[], Requirements extends readonly RequirementName[], Hidden extends boolean>(slot: Slot<Name, OldC, Events, Attributes, Requirements, Hidden>) => Slot<Name, C, Events, Attributes, Requirements, Hidden>;
|
|
227
|
+
/** Pipeable transform replacing a named slot's allowed events. */
|
|
228
|
+
declare const events: <const Next extends readonly EventName[]>(...next: Next) => <Name extends string, C extends SlotCapability, Events extends readonly EventName[], Attributes extends readonly AttributeName[], Requirements extends readonly RequirementName[], Hidden extends boolean>(slot: Slot<Name, C, Events, Attributes, Requirements, Hidden>) => Slot<Name, C, Next, Attributes, Requirements, Hidden>;
|
|
229
|
+
/** Pipeable transform replacing a named slot's allowed attributes. */
|
|
230
|
+
declare const attributes: <const Next extends readonly AttributeName[]>(...next: Next) => <Name extends string, C extends SlotCapability, Events extends readonly EventName[], Attributes extends readonly AttributeName[], Requirements extends readonly RequirementName[], Hidden extends boolean>(slot: Slot<Name, C, Events, Attributes, Requirements, Hidden>) => Slot<Name, C, Events, Next, Requirements, Hidden>;
|
|
231
|
+
/** Pipeable transform replacing a named slot's platform requirements. */
|
|
232
|
+
declare const requires: <const Next extends readonly RequirementName[]>(...next: Next) => <Name extends string, C extends SlotCapability, Events extends readonly EventName[], Attributes extends readonly AttributeName[], Requirements extends readonly RequirementName[], Hidden extends boolean>(slot: Slot<Name, C, Events, Attributes, Requirements, Hidden>) => Slot<Name, C, Events, Attributes, Next, Hidden>;
|
|
233
|
+
/** Pipeable transform marking a named slot hidden from public attachment. */
|
|
234
|
+
declare const hide: <Name extends string, C extends SlotCapability, Events extends readonly EventName[], Attributes extends readonly AttributeName[], Requirements extends readonly RequirementName[], Hidden extends boolean>(slot: Slot<Name, C, Events, Attributes, Requirements, Hidden>) => Slot<Name, C, Events, Attributes, Requirements, true>;
|
|
235
|
+
declare const describe$1: (slot: Any$1 | UnnamedSlot) => {
|
|
236
|
+
readonly name?: string;
|
|
237
|
+
readonly capability: string;
|
|
238
|
+
readonly events: ReadonlyArray<string>;
|
|
239
|
+
readonly attributes: ReadonlyArray<string>;
|
|
240
|
+
readonly requirements: ReadonlyArray<string>;
|
|
241
|
+
readonly hidden: boolean;
|
|
242
|
+
readonly protected: {
|
|
243
|
+
readonly events: ReadonlyArray<string>;
|
|
244
|
+
readonly attributes: ReadonlyArray<string>;
|
|
245
|
+
readonly style: ReadonlyArray<string>;
|
|
246
|
+
};
|
|
247
|
+
};
|
|
248
|
+
declare namespace a11y_d_exports {
|
|
249
|
+
export { A11yDiagnostic, A11yDiagnosticCode, Pattern, PatternTypeId, Requirements$1 as Requirements, SlotRequirement, pattern, validate };
|
|
250
|
+
}
|
|
251
|
+
type A11yDiagnosticCode = 'a11y:missing-slot' | 'a11y:hidden-slot' | 'a11y:capability-mismatch' | 'a11y:missing-event' | 'a11y:missing-attribute';
|
|
252
|
+
interface A11yDiagnostic extends Diagnostic {
|
|
253
|
+
readonly source: 'a11y';
|
|
254
|
+
readonly code: A11yDiagnosticCode;
|
|
255
|
+
}
|
|
256
|
+
interface SlotRequirement {
|
|
257
|
+
readonly capability?: SlotCapability;
|
|
258
|
+
readonly events?: ReadonlyArray<EventName>;
|
|
259
|
+
readonly attributes?: ReadonlyArray<AttributeName>;
|
|
260
|
+
/** An absent slot is expected, not a diagnostic. A present slot is still checked. */
|
|
261
|
+
readonly optional?: boolean;
|
|
262
|
+
}
|
|
263
|
+
type Requirements$1 = Readonly<Record<string, SlotRequirement>>;
|
|
264
|
+
declare const PatternTypeId: unique symbol;
|
|
265
|
+
interface Pattern<Spec extends Requirements$1 = Requirements$1> {
|
|
266
|
+
readonly [PatternTypeId]: {
|
|
267
|
+
readonly Requirements: Spec;
|
|
268
|
+
};
|
|
269
|
+
readonly requirements: Spec;
|
|
270
|
+
}
|
|
271
|
+
declare const pattern: <const Spec extends Requirements$1>(spec: Spec) => Pattern<Spec>;
|
|
272
|
+
declare const validate: (pattern: Pattern, slots: {
|
|
273
|
+
readonly [name: string]: Any$1;
|
|
274
|
+
}) => ReadonlyArray<A11yDiagnostic>;
|
|
275
|
+
//#endregion
|
|
276
|
+
//#region src/contribution.d.ts
|
|
277
|
+
interface StaticContribution<Message> {
|
|
278
|
+
readonly classes?: ReadonlyArray<string>;
|
|
279
|
+
readonly style?: Readonly<Record<string, string>>;
|
|
280
|
+
readonly attributes?: ReadonlyArray<Attribute<Message> | ChildAttribute>;
|
|
281
|
+
readonly mounts?: ReadonlyArray<MountAction<Message, any>>;
|
|
282
|
+
/** Compiled rule CSS for a class this contribution introduces. */
|
|
283
|
+
readonly css?: string;
|
|
284
|
+
/** Class-independent CSS this contribution introduces (keyframes, layers). */
|
|
285
|
+
readonly globalCss?: string;
|
|
286
|
+
}
|
|
287
|
+
interface ContributionContext<Message> {
|
|
288
|
+
readonly input: unknown;
|
|
289
|
+
readonly h: HtmlBuilder<Message>;
|
|
290
|
+
}
|
|
291
|
+
type DynamicContribution<Message> = (context: ContributionContext<Message>) => StaticContribution<Message>;
|
|
292
|
+
/**
|
|
293
|
+
* A contribution that reads the view input but names no Message universe, so it
|
|
294
|
+
* stays assignable to any view. Input-driven Style (`Style.whenInput`) compiles
|
|
295
|
+
* to this. It never receives `h`, because a conditional style emits no handlers.
|
|
296
|
+
*/
|
|
297
|
+
type InputContribution<Message = never> = (context: {
|
|
298
|
+
readonly input: unknown;
|
|
299
|
+
}) => StaticContribution<Message>;
|
|
300
|
+
type SlotContribution<Message> = StaticContribution<Message> | DynamicContribution<Message>;
|
|
301
|
+
type Contribution<Message> = {
|
|
302
|
+
readonly [slot: string]: SlotContribution<Message> | undefined;
|
|
303
|
+
};
|
|
304
|
+
type StaticContributionMap<Message> = {
|
|
305
|
+
readonly [slot: string]: StaticContribution<Message> | undefined;
|
|
306
|
+
};
|
|
307
|
+
declare namespace mixin_d_exports {
|
|
308
|
+
export { AnyMixin, Mixin, MixinFor, StaticMixin, compose, contributionsFor, dynamic, empty, evaluate, isDynamic, make };
|
|
309
|
+
}
|
|
310
|
+
interface Mixin<Message = never> {
|
|
311
|
+
readonly name: string;
|
|
312
|
+
readonly contributions: Contribution<Message>;
|
|
313
|
+
}
|
|
314
|
+
interface StaticMixin<Message = never> {
|
|
315
|
+
readonly name: string;
|
|
316
|
+
readonly contributions: StaticContributionMap<Message>;
|
|
317
|
+
}
|
|
318
|
+
type AnyMixin = Mixin<any> | StaticMixin<any>;
|
|
319
|
+
/**
|
|
320
|
+
* A Mixin acceptable in any context of `Message`. `Mixin<never>` is included
|
|
321
|
+
* explicitly because a message-free dynamic Mixin (input-driven Style) does not
|
|
322
|
+
* widen to `Mixin<Message>` — `HtmlBuilder` is invariant in `Message`.
|
|
323
|
+
*/
|
|
324
|
+
type MixinFor<Message> = Mixin<Message> | StaticMixin<Message> | Mixin<never>;
|
|
325
|
+
declare const isDynamic: <Message>(contribution: SlotContribution<Message>) => contribution is DynamicContribution<Message>;
|
|
326
|
+
declare const evaluate: <Message>(contribution: SlotContribution<Message>, context: ContributionContext<Message>) => StaticContribution<Message>;
|
|
327
|
+
declare const make: <Message = never>(name: string, contributions: StaticContributionMap<Message>) => StaticMixin<Message>;
|
|
328
|
+
declare const dynamic: <Message = never>(name: string, contributions: Contribution<Message>) => Mixin<Message>;
|
|
329
|
+
declare const empty: <Message = never>() => StaticMixin<Message>;
|
|
330
|
+
declare const compose: <Message = never>(...mixins: ReadonlyArray<MixinFor<Message>>) => Mixin<Message>;
|
|
331
|
+
declare const contributionsFor: <Message>(mixin: Mixin<Message> | StaticMixin<Message>, slot: string) => SlotContribution<Message> | undefined;
|
|
332
|
+
declare namespace resolver_d_exports {
|
|
333
|
+
export { ResolveOptions, SlotAttributes, resolve };
|
|
334
|
+
}
|
|
335
|
+
type SlotAttributes<Message> = ReadonlyArray<Attribute<Message> | ChildAttribute>;
|
|
336
|
+
interface ResolveOptions {
|
|
337
|
+
readonly slot?: string;
|
|
338
|
+
readonly protected?: SlotProtection;
|
|
339
|
+
}
|
|
340
|
+
declare const resolve: <Message>(base: SlotAttributes<Message> | undefined, contributions: ReadonlyArray<StaticContribution<Message>>, options?: ResolveOptions) => SlotAttributes<Message>;
|
|
341
|
+
declare namespace slotView_d_exports {
|
|
342
|
+
export { SlotBuilder, SlotBuilders, SlotView, SlotViewRender, SlotViewTransform, SlotViewTransformFor, attach$1 as attach, buildersFor, define$1 as define };
|
|
343
|
+
}
|
|
344
|
+
type SlotBuilder<Message> = {
|
|
345
|
+
readonly attrs: (base?: SlotAttributes<Message>) => SlotAttributes<Message>;
|
|
346
|
+
};
|
|
347
|
+
type SlotBuilders<Slots, Message> = { readonly [K in keyof Slots]: SlotBuilder<Message>; };
|
|
348
|
+
type SlotViewRender<Slots, Input, Message> = (input: Input, slots: SlotBuilders<Slots, Message>, h: HtmlBuilder<Message>) => Html;
|
|
349
|
+
interface SlotView<Slots, Input, Message> extends Pipeable<SlotView<Slots, Input, Message>> {
|
|
350
|
+
(input: Input, h: HtmlBuilder<Message>): Html;
|
|
351
|
+
readonly name?: string;
|
|
352
|
+
readonly slots: Slots;
|
|
353
|
+
readonly mixins: ReadonlyArray<MixinFor<Message>>;
|
|
354
|
+
readonly render: SlotViewRender<Slots, Input, Message>;
|
|
355
|
+
}
|
|
356
|
+
/** Build one `attrs` resolver per published slot, evaluating Mixins lazily. */
|
|
357
|
+
declare const buildersFor: <Slots, Message, Input>(slots: Slots, mixins: ReadonlyArray<MixinFor<Message>>, context: {
|
|
358
|
+
readonly input: Input;
|
|
359
|
+
readonly h: HtmlBuilder<Message>;
|
|
360
|
+
}) => SlotBuilders<Slots, Message>;
|
|
361
|
+
declare const define$1: <Slots, Input, Message>(slots: Slots, render: SlotViewRender<Slots, Input, Message>, options?: {
|
|
362
|
+
readonly name?: string;
|
|
363
|
+
}) => SlotView<Slots, Input, Message>;
|
|
364
|
+
/** A transform on any view, used by Message-free static mixins such as Style. */
|
|
365
|
+
type SlotViewTransform = <Slots, Input, Message>(view: SlotView<Slots, Input, Message>) => SlotView<Slots, Input, Message>;
|
|
366
|
+
/** A transform restricted to one Message universe, for Behavior mixins. */
|
|
367
|
+
type SlotViewTransformFor<Message> = <Slots, Input>(view: SlotView<Slots, Input, Message>) => SlotView<Slots, Input, Message>;
|
|
368
|
+
/** Attach one Mixin. Returns a new view; the original is unchanged. */
|
|
369
|
+
declare function attach$1(mixin: StaticMixin<never> | Mixin<never>): SlotViewTransform;
|
|
370
|
+
declare function attach$1<MixinMessage>(mixin: Mixin<MixinMessage>): SlotViewTransformFor<MixinMessage>;
|
|
371
|
+
declare namespace behavior_d_exports {
|
|
372
|
+
export { Behavior, BehaviorSlotOptions, BehaviorSpec, NamedBehavior, SlotRequirements, attach, forSlots, slot };
|
|
373
|
+
}
|
|
374
|
+
interface SlotRequirements {
|
|
375
|
+
readonly capability?: SlotCapability;
|
|
376
|
+
readonly events?: ReadonlyArray<EventName>;
|
|
377
|
+
readonly attributes?: ReadonlyArray<AttributeName>;
|
|
378
|
+
}
|
|
379
|
+
interface BehaviorSlotOptions<Input, Message> {
|
|
380
|
+
readonly requires?: SlotRequirements;
|
|
381
|
+
readonly attributes?: (context: {
|
|
382
|
+
readonly input: Input;
|
|
383
|
+
readonly h: HtmlBuilder<Message>;
|
|
384
|
+
}) => ReadonlyArray<Attribute<Message> | ChildAttribute>;
|
|
385
|
+
readonly mount?: (input: Input) => MountAction<Message, any>;
|
|
386
|
+
}
|
|
387
|
+
type BehaviorSpec<Slots, Input, Message> = { readonly [K in keyof Slots as HiddenOf<Slots[K]> extends true ? never : K]?: BehaviorSlotOptions<Input, Message>; };
|
|
388
|
+
interface NamedBehavior<Slots, Input, Message> {
|
|
389
|
+
readonly name?: string;
|
|
390
|
+
readonly spec: BehaviorSpec<Slots, Input, Message>;
|
|
391
|
+
readonly mixin: Mixin<Message>;
|
|
392
|
+
}
|
|
393
|
+
/** Identity helper; `forSlots` supplies the contextual `Input`/`Message`. */
|
|
394
|
+
declare const slot: <Options extends BehaviorSlotOptions<any, any>>(options: Options) => Options;
|
|
395
|
+
declare const forSlots: <Slots>(slots: Slots) => <Input, Message>(spec: BehaviorSpec<Slots, Input, Message>, options?: {
|
|
396
|
+
readonly name?: string;
|
|
397
|
+
}) => NamedBehavior<Slots, Input, Message>;
|
|
398
|
+
declare const attach: <BehaviorSlots, Message, Input>(behavior: NamedBehavior<BehaviorSlots, Input, Message>) => <ViewSlots>(view: SlotView<ViewSlots, Input, Message>) => SlotView<ViewSlots, Input, Message>;
|
|
399
|
+
declare const Behavior: {
|
|
400
|
+
readonly slot: <Options extends BehaviorSlotOptions<any, any>>(options: Options) => Options;
|
|
401
|
+
readonly forSlots: <Slots>(slots: Slots) => <Input, Message>(spec: BehaviorSpec<Slots, Input, Message>, options?: {
|
|
402
|
+
readonly name?: string;
|
|
403
|
+
}) => NamedBehavior<Slots, Input, Message>;
|
|
404
|
+
readonly attach: <BehaviorSlots, Message, Input>(behavior: NamedBehavior<BehaviorSlots, Input, Message>) => <ViewSlots>(view: SlotView<ViewSlots, Input, Message>) => SlotView<ViewSlots, Input, Message>;
|
|
405
|
+
};
|
|
406
|
+
declare namespace slots_d_exports {
|
|
407
|
+
export { Contract, HiddenNamesOf, NamesOf, PublicNamesOf, SlotsTypeId, WithCapability, define, describe, withCapability };
|
|
408
|
+
}
|
|
409
|
+
declare const SlotsTypeId: unique symbol;
|
|
410
|
+
type Contract<S extends { readonly [K in keyof S]: UnnamedSlot | MakeOptions; }> = { readonly [K in keyof S]: S[K] extends UnnamedSlot<infer C, infer Events, infer Attributes, infer Requirements, infer Hidden> ? Slot<K & string, C, Events, Attributes, Requirements, Hidden> : S[K] extends MakeOptions<infer C, infer Events, infer Attributes, infer Requirements, infer Hidden> ? Slot<K & string, C, Events, Attributes, Requirements, Hidden> : never; };
|
|
411
|
+
type NamesOf<T> = keyof T & string;
|
|
412
|
+
type PublicNamesOf<T> = { readonly [K in keyof T & string]: HiddenOf<T[K]> extends true ? never : K; }[keyof T & string];
|
|
413
|
+
type HiddenNamesOf<T> = { readonly [K in keyof T & string]: HiddenOf<T[K]> extends true ? K : never; }[keyof T & string];
|
|
414
|
+
type WithCapability<T, C extends SlotCapability> = { readonly [K in keyof T & string as NameOf$1<C> extends AssignableCapabilityNamesOf<T[K]> ? K : never]: T[K]; };
|
|
415
|
+
declare const define: <const S extends { readonly [K in keyof S]: UnnamedSlot | MakeOptions; }>(spec: S) => Contract<S>;
|
|
416
|
+
declare const describe: (contract: {
|
|
417
|
+
readonly [key: string]: Any$1 | UnnamedSlot;
|
|
418
|
+
}) => {
|
|
419
|
+
readonly slots: Readonly<Record<string, {
|
|
420
|
+
readonly name: string;
|
|
421
|
+
readonly capability: string;
|
|
422
|
+
readonly events: ReadonlyArray<string>;
|
|
423
|
+
readonly attributes: ReadonlyArray<string>;
|
|
424
|
+
readonly requirements: ReadonlyArray<string>;
|
|
425
|
+
readonly hidden: boolean;
|
|
426
|
+
readonly protected: {
|
|
427
|
+
readonly events: ReadonlyArray<string>;
|
|
428
|
+
readonly attributes: ReadonlyArray<string>;
|
|
429
|
+
readonly style: ReadonlyArray<string>;
|
|
430
|
+
};
|
|
431
|
+
}>>;
|
|
432
|
+
};
|
|
433
|
+
declare const withCapability: <T extends {
|
|
434
|
+
readonly [key: string]: Any$1;
|
|
435
|
+
}, C extends SlotCapability>(contract: T, capability: C) => WithCapability<T, C>;
|
|
436
|
+
//#endregion
|
|
437
|
+
//#region src/styleRules.d.ts
|
|
438
|
+
/**
|
|
439
|
+
* Deterministic compilation of rule-based Style. A rule selector is written
|
|
440
|
+
* relative to the generated class with `&` (`&:hover`). The class name is an
|
|
441
|
+
* FNV-1a hash of the canonical rule text, so equal rules share a class and the
|
|
442
|
+
* server and the browser derive the same name. Pure data in, CSS text out: no
|
|
443
|
+
* registry, no DOM, no `Date.now`.
|
|
444
|
+
*/
|
|
445
|
+
interface StyleRule {
|
|
446
|
+
readonly selector: string;
|
|
447
|
+
readonly at?: string;
|
|
448
|
+
readonly declarations: Readonly<Record<string, string>>;
|
|
449
|
+
}
|
|
450
|
+
//#endregion
|
|
451
|
+
//#region src/style.d.ts
|
|
452
|
+
interface StyleValue {
|
|
453
|
+
readonly classes: ReadonlyArray<string>;
|
|
454
|
+
readonly style: Readonly<Record<string, string>>;
|
|
455
|
+
/** Input-driven pieces resolved at render time; empty for a static style. */
|
|
456
|
+
readonly conditions?: ReadonlyArray<StyleCondition>;
|
|
457
|
+
/** Rule-based appearance compiled to a deterministic class plus CSS. */
|
|
458
|
+
readonly rules?: ReadonlyArray<StyleRule>;
|
|
459
|
+
/** Class-independent CSS (keyframes, layers, global rules). */
|
|
460
|
+
readonly globalCss?: ReadonlyArray<string>;
|
|
461
|
+
}
|
|
462
|
+
interface StyleCondition {
|
|
463
|
+
readonly predicate: (input: unknown) => boolean;
|
|
464
|
+
readonly piece: StyleValue;
|
|
465
|
+
}
|
|
466
|
+
/** A hidden slot is internal: it is neither styleable nor behavior-targetable. */
|
|
467
|
+
type StylePieces<Slots> = { readonly [K in keyof Slots as HiddenOf<Slots[K]> extends true ? never : K]?: StyleValue; };
|
|
468
|
+
interface NamedStyle<Slots> {
|
|
469
|
+
readonly name?: string;
|
|
470
|
+
readonly pieces: StylePieces<Slots>;
|
|
471
|
+
readonly mixin: Mixin<never>;
|
|
472
|
+
/** Concatenated rule CSS for every static piece. */
|
|
473
|
+
readonly css: string;
|
|
474
|
+
/** Concatenated class-independent CSS (keyframes, layers, global rules). */
|
|
475
|
+
readonly globalCss: string;
|
|
476
|
+
/** One entry per generated class, for a deduplicating stylesheet. */
|
|
477
|
+
readonly rules: ReadonlyArray<{
|
|
478
|
+
readonly className: string;
|
|
479
|
+
readonly css: string;
|
|
480
|
+
}>;
|
|
481
|
+
/** Class-independent rule chunks, for a deduplicating stylesheet. */
|
|
482
|
+
readonly globalRules: ReadonlyArray<string>;
|
|
483
|
+
}
|
|
484
|
+
type RecipeVariantDef = Readonly<Record<string, StyleValue>>;
|
|
485
|
+
/** A combination style applied when every `when` entry matches the selection. */
|
|
486
|
+
interface RecipeCompound<Variants extends Readonly<Record<string, RecipeVariantDef>>> {
|
|
487
|
+
readonly when: Partial<{ readonly [K in keyof Variants]: keyof Variants[K] & string; }>;
|
|
488
|
+
readonly style: StyleValue;
|
|
489
|
+
}
|
|
490
|
+
interface RecipeDef<Variants extends Readonly<Record<string, RecipeVariantDef>>> {
|
|
491
|
+
readonly base?: StyleValue;
|
|
492
|
+
readonly variants: Variants;
|
|
493
|
+
readonly defaults?: { readonly [K in keyof Variants]?: keyof Variants[K] & string; };
|
|
494
|
+
readonly compound?: ReadonlyArray<RecipeCompound<Variants>>;
|
|
495
|
+
}
|
|
496
|
+
type AnyRecipeDef = RecipeDef<Record<string, RecipeVariantDef>>;
|
|
497
|
+
type RecipeSelection<D extends AnyRecipeDef> = { readonly [K in keyof D['variants']]?: keyof D['variants'][K] & string; };
|
|
498
|
+
export declare const Style: {
|
|
499
|
+
readonly class: (value: string) => StyleValue;
|
|
500
|
+
readonly inline: (value: Readonly<Record<string, string>>) => StyleValue;
|
|
501
|
+
readonly compose: (...pieces: ReadonlyArray<StyleValue>) => StyleValue;
|
|
502
|
+
readonly when: (condition: boolean, piece: StyleValue) => StyleValue;
|
|
503
|
+
readonly whenInput: <Input>(predicate: (input: Input) => boolean, piece: StyleValue) => StyleValue;
|
|
504
|
+
readonly pseudo: (suffix: string, declarations: Readonly<Record<string, string>>) => StyleValue;
|
|
505
|
+
readonly media: (query: string, declarations: Readonly<Record<string, string>>) => StyleValue;
|
|
506
|
+
readonly supports: (condition: string, declarations: Readonly<Record<string, string>>) => StyleValue;
|
|
507
|
+
readonly container: (condition: string, declarations: Readonly<Record<string, string>>) => StyleValue;
|
|
508
|
+
readonly nest: (selector: string, declarations: Readonly<Record<string, string>>) => StyleValue;
|
|
509
|
+
readonly keyframes: (frames: Readonly<Record<string, Readonly<Record<string, string>>>>) => {
|
|
510
|
+
readonly name: string;
|
|
511
|
+
readonly style: StyleValue;
|
|
512
|
+
};
|
|
513
|
+
readonly global: (css: string) => StyleValue;
|
|
514
|
+
readonly empty: StyleValue;
|
|
515
|
+
readonly forSlots: <Slots>(slots: Slots) => (pieces: StylePieces<Slots>, options?: {
|
|
516
|
+
readonly name?: string;
|
|
517
|
+
}) => NamedStyle<Slots>;
|
|
518
|
+
readonly attach: <Slots>(style: NamedStyle<Slots>) => <ViewSlots, Input, Message>(view: SlotView<ViewSlots, Input, Message>) => SlotView<ViewSlots, Input, Message>;
|
|
519
|
+
readonly recipe: <Variants extends Readonly<Record<string, RecipeVariantDef>>>(def: RecipeDef<Variants>) => (selection: RecipeSelection<RecipeDef<Variants>>) => StyleValue;
|
|
520
|
+
readonly stylesheet: (...styles: ReadonlyArray<{
|
|
521
|
+
readonly rules: ReadonlyArray<{
|
|
522
|
+
readonly className: string;
|
|
523
|
+
readonly css: string;
|
|
524
|
+
}>;
|
|
525
|
+
readonly globalRules: ReadonlyArray<string>;
|
|
526
|
+
}>) => string;
|
|
527
|
+
};
|
|
528
|
+
//#endregion
|
|
529
|
+
//#region src/theme.d.ts
|
|
530
|
+
type ThemeTokens = {
|
|
531
|
+
readonly [group: string]: {
|
|
532
|
+
readonly [name: string]: string;
|
|
533
|
+
};
|
|
534
|
+
};
|
|
535
|
+
export type Theme<T extends ThemeTokens = ThemeTokens> = T;
|
|
536
|
+
export declare const Theme: {
|
|
537
|
+
readonly define: <T extends ThemeTokens>(tokens: T) => Readonly<T>;
|
|
538
|
+
readonly variable: <T extends ThemeTokens, G extends keyof T & string>(_theme: T, group: G, name: keyof T[G] & string) => string;
|
|
539
|
+
readonly variables: <T extends ThemeTokens>(theme: T) => StyleValue;
|
|
540
|
+
};
|
|
541
|
+
//#endregion
|
|
542
|
+
export { a11y_d_exports as A11y, type A11yDiagnostic, type A11yDiagnosticCode, type Pattern as A11yPattern, type SlotRequirement as A11yRequirement, type Any as AnyCapability, type AnyMixin, attr_d_exports as Attr, type AttrToken, behavior_d_exports as Behavior, type BehaviorSlotOptions, type BehaviorSpec, capability_d_exports as Capability, type Contribution, type ContributionContext, type Diagnostic, type DiagnosticCode, diagnostics_d_exports as Diagnostics, type DynamicContribution, event_d_exports as Event, type EventToken, type InputContribution, metadataToken_d_exports as MetadataToken, mixin_d_exports as Mixin, type MixinFor, type Mixin as MixinValue, type NamedBehavior, type NamedStyle, requirement_d_exports as Requirement, type RequirementToken, type ResolveOptions, resolver_d_exports as Resolver, type Satisfies, slot_d_exports as Slot, type SlotAttributes, type SlotBuilder, type SlotBuilders, type SlotContribution, type SlotProtection, type SlotRequirements, slotView_d_exports as SlotView, type SlotViewRender, type SlotViewTransform, type SlotViewTransformFor, slots_d_exports as Slots, type Contract as SlotsContract, type StaticContribution, type StaticContributionMap, type StaticMixin, type StyleCondition, type StylePieces, type StyleRule, type StyleValue, type Theme as ThemeValue, type ThemeTokens, type UnnamedSlot };
|
|
543
|
+
//# sourceMappingURL=index.d.mts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"index.d.mts","names":[],"sources":["../src/diagnostics.ts","../src/metadataToken.ts","../src/attr.ts","../src/capability.ts","../src/event.ts","../src/pipe.ts","../src/requirement.ts","../src/slot.ts","../src/a11y.ts","../src/contribution.ts","../src/mixin.ts","../src/resolver.ts","../src/slotView.ts","../src/behavior.ts","../src/slots.ts","../src/styleRules.ts","../src/style.ts","../src/theme.ts"],"mappings":"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"}
|