Skip to content

Commit d8afa8e

Browse files
sinclairzx81sinclairzx81
committed
updateS
1 parent 89b47fd commit d8afa8e

28 files changed

+1038
-315
lines changed

‎src/runtime/types.ts‎

Lines changed: 4 additions & 294 deletions
Original file line numberDiff line numberDiff line change
@@ -33,305 +33,15 @@ import { Guard } from '../guard/index.ts'
3333

3434
export type IProperties = Record<PropertyKey, IParser>
3535

36-
// ------------------------------------------------------------------
37-
// Static
38-
// ------------------------------------------------------------------
3936

40-
/** Force output static type evaluation for Arrays */
41-
export type StaticEnsure<T> = T extends infer R ? R : never
4237

43-
/** Infers the Output Parameter for a Parser */
44-
export type StaticParser<Parser extends IParser> = Parser extends IParser<infer Output extends unknown>
45-
? Output
46-
: unknown
4738

48-
// ------------------------------------------------------------------
49-
// Mapping
50-
// ------------------------------------------------------------------
51-
export type IMapping<Input extends unknown = any, Output extends unknown = unknown> = (input: Input) => Output
5239

53-
/** Maps input to output. This is the default Mapping */
54-
export const Identity = (value: unknown) => value
5540

56-
/** Maps the output as the given parameter T */
57-
export function As<T>(mapping: T): ((value: unknown) => T) {
58-
return (_: unknown) => mapping
59-
}
60-
// ------------------------------------------------------------------
61-
// Parser
62-
// ------------------------------------------------------------------
63-
export interface IParser<Output extends unknown = unknown> {
64-
type: string
65-
mapping: IMapping<any, Output>
66-
}
67-
// ------------------------------------------------------------------
68-
// Array
69-
// ------------------------------------------------------------------
70-
export type ArrayParameter<Parser extends IParser> = StaticEnsure<
71-
StaticParser<Parser>[]
72-
>
73-
export interface IArray<Output extends unknown = unknown> extends IParser<Output> {
74-
type: 'Array'
75-
parser: IParser
76-
}
77-
/** `[EBNF]` Creates an Array Parser */
78-
export function Array<Parser extends IParser, Mapping extends IMapping = IMapping<ArrayParameter<Parser>>>(parser: Parser, mapping: Mapping): IArray<ReturnType<Mapping>>
79-
/** `[EBNF]` Creates an Array Parser */
80-
export function Array<Parser extends IParser>(parser: Parser): IArray<ArrayParameter<Parser>>
81-
/** `[EBNF]` Creates an Array Parser */
82-
export function Array(...args: unknown[]): never {
83-
const [parser, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity]
84-
return { type: 'Array', parser, mapping } as never
85-
}
86-
/** Returns true if the value is a Array Parser */
87-
export function IsArray(value: unknown): value is IArray {
88-
return Guard.IsObject(value)
89-
&& Guard.HasPropertyKey(value, 'type')
90-
&& Guard.HasPropertyKey(value, 'parser')
91-
&& Guard.IsEqual(value.type, 'Array')
92-
&& Guard.IsObject(value.parser)
93-
}
94-
// ------------------------------------------------------------------
95-
// Const
96-
// ------------------------------------------------------------------
97-
export interface IConst<Output extends unknown = unknown> extends IParser<Output> {
98-
type: 'Const'
99-
value: string
100-
}
101-
/** Creates a Const Parser */
102-
export function Const<Value extends string, Mapping extends IMapping<Value>>(value: Value, mapping: Mapping): IConst<ReturnType<Mapping>>
103-
/** Creates a Const Parser */
104-
export function Const<Value extends string>(value: Value): IConst<Value>
105-
/** Creates a Const Parser */
106-
export function Const(...args: unknown[]): never {
107-
const [value, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity]
108-
return { type: 'Const', value, mapping } as never
109-
}
110-
/** Returns true if the value is a Const Parser */
111-
export function IsConst(value: unknown): value is IConst {
112-
return Guard.IsObject(value)
113-
&& Guard.HasPropertyKey(value, 'type')
114-
&& Guard.HasPropertyKey(value, 'value')
115-
&& Guard.IsEqual(value.type, 'Const')
116-
&& Guard.IsString(value.value)
117-
}
118-
// ------------------------------------------------------------------
119-
// Ref
120-
// ------------------------------------------------------------------
121-
export interface IRef<Output extends unknown = unknown> extends IParser<Output> {
122-
type: 'Ref'
123-
ref: string
124-
}
125-
/** Creates a Ref Parser. This Parser can only be used in the context of a Module */
126-
export function Ref<Type extends unknown, Mapping extends IMapping<Type>>(ref: string, mapping: Mapping): IRef<ReturnType<Mapping>>
127-
/** Creates a Ref Parser. This Parser can only be used in the context of a Module */
128-
export function Ref<Type extends unknown>(ref: string): IRef<Type>
129-
/** Creates a Ref Parser. This Parser can only be used in the context of a Module */
130-
export function Ref(...args: unknown[]): never {
131-
const [ref, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity]
132-
return { type: 'Ref', ref, mapping } as never
133-
}
134-
/** Returns true if the value is a Ref Parser */
135-
export function IsRef(value: unknown): value is IRef {
136-
return Guard.IsObject(value)
137-
&& Guard.HasPropertyKey(value, 'type')
138-
&& Guard.HasPropertyKey(value, 'ref')
139-
&& Guard.IsEqual(value.type, 'Ref')
140-
&& Guard.IsString(value.ref)
141-
}
142-
// ------------------------------------------------------------------
143-
// String
144-
// ------------------------------------------------------------------
145-
export interface IString<Output extends unknown = unknown> extends IParser<Output> {
146-
type: 'String'
147-
}
148-
/** Creates a String Parser. */
149-
export function String<Mapping extends IMapping<string>>(mapping: Mapping): IString<ReturnType<Mapping>>
150-
/** Creates a String Parser. */
151-
export function String(): IString<string>
152-
/** Creates a String Parser. */
153-
export function String(...params: unknown[]): never {
154-
const [mapping] = params.length === 1 ? [params[0]] : [Identity]
155-
return { type: 'String', mapping } as never
156-
}
157-
/** Returns true if the value is a String Parser */
158-
export function IsString(value: unknown): value is IString {
159-
return Guard.IsObject(value)
160-
&& Guard.HasPropertyKey(value, 'type')
161-
&& Guard.IsEqual(value.type, 'String')
162-
}
163-
// ------------------------------------------------------------------
164-
// Ident
165-
// ------------------------------------------------------------------
166-
export interface IIdent<Output extends unknown = unknown> extends IParser<Output> {
167-
type: 'Ident'
168-
}
169-
/** Creates an Ident Parser where Ident matches any valid JavaScript identifier */
170-
export function Ident<Mapping extends IMapping<string>>(mapping: Mapping): IIdent<ReturnType<Mapping>>
171-
/** Creates an Ident Parser where Ident matches any valid JavaScript identifier */
172-
export function Ident(): IIdent<string>
173-
/** Creates an Ident Parser where Ident matches any valid JavaScript identifier */
174-
export function Ident(...params: unknown[]): never {
175-
const mapping = params.length === 1 ? params[0] : Identity
176-
return { type: 'Ident', mapping } as never
177-
}
178-
/** Returns true if the value is a Ident Parser */
179-
export function IsIdent(value: unknown): value is IIdent {
180-
return Guard.IsObject(value)
181-
&& Guard.HasPropertyKey(value, 'type')
182-
&& Guard.IsEqual(value.type, 'Ident')
183-
}
184-
// ------------------------------------------------------------------
185-
// Number
186-
// ------------------------------------------------------------------
187-
export interface INumber<Output extends unknown = unknown> extends IParser<Output> {
188-
type: 'Number'
189-
}
190-
/** Creates an Number Parser */
191-
export function Number<Mapping extends IMapping<string>>(mapping: Mapping): INumber<ReturnType<Mapping>>
192-
/** Creates an Number Parser */
193-
export function Number(): INumber<string>
194-
/** Creates an Number Parser */
195-
export function Number(...params: unknown[]): never {
196-
const mapping = params.length === 1 ? params[0] : Identity
197-
return { type: 'Number', mapping } as never
198-
}
199-
/** Returns true if the value is a Number Parser */
200-
export function IsNumber(value: unknown): value is INumber {
201-
return Guard.IsObject(value)
202-
&& Guard.HasPropertyKey(value, 'type')
203-
&& Guard.IsEqual(value.type, 'Number')
204-
}
205-
// ------------------------------------------------------------------
206-
// Optional
207-
// ------------------------------------------------------------------
208-
export type OptionalParameter<Parser extends IParser, Result extends unknown = [StaticParser<Parser>] | []> = (
209-
Result
210-
)
211-
export interface IOptional<Output extends unknown = unknown> extends IParser<Output> {
212-
type: 'Optional'
213-
parser: IParser
214-
}
215-
/** `[EBNF]` Creates an Optional Parser */
216-
export function Optional<Parser extends IParser, Mapping extends IMapping = IMapping<OptionalParameter<Parser>>>(parser: Parser, mapping: Mapping): IOptional<ReturnType<Mapping>>
217-
/** `[EBNF]` Creates an Optional Parser */
218-
export function Optional<Parser extends IParser>(parser: Parser): IOptional<OptionalParameter<Parser>>
219-
/** `[EBNF]` Creates an Optional Parser */
220-
export function Optional(...args: unknown[]): never {
221-
const [parser, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity]
222-
return { type: 'Optional', parser, mapping } as never
223-
}
224-
/** Returns true if the value is a Optional Parser */
225-
export function IsOptional(value: unknown): value is IOptional {
226-
return Guard.IsObject(value)
227-
&& Guard.HasPropertyKey(value, 'type')
228-
&& Guard.HasPropertyKey(value, 'parser')
229-
&& Guard.IsEqual(value.type, 'Optional')
230-
&& Guard.IsObject(value.parser)
231-
}
232-
// ------------------------------------------------------------------
233-
// Tuple
234-
// ------------------------------------------------------------------
235-
export type TupleParameter<Parsers extends IParser[], Result extends unknown[] = []> = StaticEnsure<
236-
Parsers extends [infer Left extends IParser, ...infer Right extends IParser[]]
237-
? TupleParameter<Right, [...Result, StaticEnsure<StaticParser<Left>>]>
238-
: Result
239-
>
240-
export interface ITuple<Output extends unknown = unknown> extends IParser<Output> {
241-
type: 'Tuple'
242-
parsers: IParser[]
243-
}
244-
/** Creates a Tuple Parser */
245-
export function Tuple<Parsers extends IParser[], Mapping extends IMapping = IMapping<TupleParameter<Parsers>>>(parsers: [...Parsers], mapping: Mapping): ITuple<ReturnType<Mapping>>
246-
/** Creates a Tuple Parser */
247-
export function Tuple<Parsers extends IParser[]>(parsers: [...Parsers]): ITuple<TupleParameter<Parsers>>
248-
/** Creates a Tuple Parser */
249-
export function Tuple(...args: unknown[]): never {
250-
const [parsers, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity]
251-
return { type: 'Tuple', parsers, mapping } as never
252-
}
253-
/** Returns true if the value is a Tuple Parser */
254-
export function IsTuple(value: unknown): value is ITuple {
255-
return Guard.IsObject(value)
256-
&& Guard.HasPropertyKey(value, 'type')
257-
&& Guard.HasPropertyKey(value, 'parsers')
258-
&& Guard.IsEqual(value.type, 'Tuple')
259-
&& Guard.IsArray(value.parsers)
260-
}
261-
// ------------------------------------------------------------------
262-
// Union
263-
// ------------------------------------------------------------------
264-
export type UnionParameter<Parsers extends IParser[], Result extends unknown = never> = StaticEnsure<
265-
Parsers extends [infer Left extends IParser, ...infer Right extends IParser[]]
266-
? UnionParameter<Right, Result | StaticParser<Left>>
267-
: Result
268-
>
269-
export interface IUnion<Output extends unknown = unknown> extends IParser<Output> {
270-
type: 'Union'
271-
parsers: IParser[]
272-
}
273-
/** Creates a Union parser */
274-
export function Union<Parsers extends IParser[], Mapping extends IMapping = IMapping<UnionParameter<Parsers>>>(parsers: [...Parsers], mapping: Mapping): IUnion<ReturnType<Mapping>>
275-
/** Creates a Union parser */
276-
export function Union<Parsers extends IParser[]>(parsers: [...Parsers]): IUnion<UnionParameter<Parsers>>
277-
/** Creates a Union parser */
278-
export function Union(...args: unknown[]): never {
279-
const [parsers, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity]
280-
return { type: 'Union', parsers, mapping } as never
281-
}
282-
/** Returns true if the value is a Union Parser */
283-
export function IsUnion(value: unknown): value is IUnion {
284-
return Guard.IsObject(value)
285-
&& Guard.HasPropertyKey(value, 'type')
286-
&& Guard.HasPropertyKey(value, 'parsers')
287-
&& Guard.IsEqual(value.type, 'Union')
288-
&& Guard.IsArray(value.parsers)
289-
}
290-
// ------------------------------------------------------------------
291-
// Until
292-
// ------------------------------------------------------------------
293-
export interface IUntil<Output extends unknown = unknown> extends IParser<Output> {
294-
type: 'Until'
295-
values: string[]
296-
}
297-
/** Creates a Until Parser */
298-
export function Until<Mapping extends IMapping<string>>(values: string[], mapping: Mapping): IUntil<string>
299-
/** Creates a Until Parser */
300-
export function Until(values: string[]): IUntil<string>
301-
/** Creates a Until Parser */
302-
export function Until(...args: unknown[]): never {
303-
const [values, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity]
304-
return { type: 'Until', values, mapping } as never
305-
}
306-
/** Returns true if the value is a Until Parser */
307-
export function IsUntil(value: unknown): value is IUntil {
308-
return Guard.IsObject(value)
309-
&& Guard.HasPropertyKey(value, 'type')
310-
&& Guard.HasPropertyKey(value, 'values')
311-
&& Guard.IsEqual(value.type, 'Until')
312-
&& Guard.IsArray(value.values)
313-
}
41+
42+
43+
44+
31445
// ------------------------------------------------------------------
31546
// UntilNonEmpty
31647
// ------------------------------------------------------------------
317-
export interface IUntil_1<Output extends unknown = unknown> extends IParser<Output> {
318-
type: 'UntilNonEmpty'
319-
values: string[]
320-
}
321-
/** Creates a UntilNonEmpty Parser */
322-
export function Until_1<Mapping extends IMapping<string>>(values: string[], mapping: Mapping): IUntil_1<string>
323-
/** Creates a UntilNonEmpty Parser */
324-
export function Until_1(values: string[]): IUntil_1<string>
325-
/** Creates a UntilNonEmpty Parser */
326-
export function Until_1(...args: unknown[]): never {
327-
const [end, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity]
328-
return { type: 'UntilNonEmpty', values: end, mapping } as never
329-
}
330-
/** Returns true if the value is a UntilNonEmpty Parser */
331-
export function IsUntil_1(value: unknown): value is IUntil_1 {
332-
return Guard.IsObject(value)
333-
&& Guard.HasPropertyKey(value, 'type')
334-
&& Guard.HasPropertyKey(value, 'end')
335-
&& Guard.IsEqual(value.type, 'Until_1')
336-
&& Guard.IsArray(value.end)
337-
}

‎src/runtime/types/array.ts‎

Lines changed: 74 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,74 @@
1+
/*--------------------------------------------------------------------------
2+
3+
ParseBox
4+
5+
The MIT License (MIT)
6+
7+
Copyright (c) 2024-2025 Haydn Paterson
8+
9+
Permission is hereby granted, free of charge, to any person obtaining a copy
10+
of this software and associated documentation files (the "Software"), to deal
11+
in the Software without restriction, including without limitation the rights
12+
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13+
copies of the Software, and to permit persons to whom the Software is
14+
furnished to do so, subject to the following conditions:
15+
16+
The above copyright notice and this permission notice shall be included in
17+
all copies or substantial portions of the Software.
18+
19+
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20+
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21+
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22+
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23+
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24+
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25+
THE SOFTWARE.
26+
27+
---------------------------------------------------------------------------*/
28+
29+
// deno-fmt-ignore-file
30+
31+
import { Arguments } from '../../system/arguments/index.ts'
32+
import { Guard } from '../../guard/index.ts'
33+
import { type StaticParser, type StaticEnsure } from './static.ts'
34+
import { type IParser, type IMapping, Identity } from './parser.ts'
35+
36+
// ------------------------------------------------------------------
37+
// Static
38+
// ------------------------------------------------------------------
39+
export type StaticArray<Parser extends IParser> = StaticEnsure<
40+
StaticParser<Parser>[]
41+
>
42+
// ------------------------------------------------------------------
43+
// Type
44+
// ------------------------------------------------------------------
45+
export interface IArray<Output extends unknown = unknown> extends IParser<Output> {
46+
type: 'Array'
47+
parser: IParser
48+
}
49+
// ------------------------------------------------------------------
50+
// Factory
51+
// ------------------------------------------------------------------
52+
/** Creates an Array parser */
53+
export function Array<Parser extends IParser, Mapping extends IMapping = IMapping<StaticArray<Parser>>>(parser: Parser, mapping: Mapping): IArray<ReturnType<Mapping>>
54+
/** Creates an Array parser */
55+
export function Array<Parser extends IParser>(parser: Parser): IArray<StaticArray<Parser>>
56+
/** Creates an Array parser */
57+
export function Array(...args: unknown[]): never {
58+
const [parser, mapping] = Arguments.Match<[IParser, IMapping]>(args, {
59+
2: (parser, mapping) => [parser, mapping],
60+
1: (parser) => [parser, Identity]
61+
})
62+
return { type: 'Array', parser, mapping } as never
63+
}
64+
// ------------------------------------------------------------------
65+
// Guard
66+
// ------------------------------------------------------------------
67+
/** True if the value is a Array parser */
68+
export function IsArray(value: unknown): value is IArray {
69+
return Guard.IsObject(value)
70+
&& Guard.HasPropertyKey(value, 'type')
71+
&& Guard.HasPropertyKey(value, 'parser')
72+
&& Guard.IsEqual(value.type, 'Array')
73+
&& Guard.IsObject(value.parser)
74+
}

0 commit comments

Comments
 (0)