95 lines
3.7 KiB
TypeScript
95 lines
3.7 KiB
TypeScript
import { stringify } from "@preserves/core";
|
|
import * as M from "./meta";
|
|
import { CompilerOptions, ModuleContext } from "./compiler/context";
|
|
import { Formatter, block, seq } from "./compiler/block";
|
|
import { typeForDefinition } from "./compiler/gentype";
|
|
import { converterForDefinition } from "./compiler/genconverter";
|
|
import { renderType, Type } from "./compiler/type";
|
|
import { genConstructor } from "./compiler/genctor";
|
|
import { unconverterForDefinition } from "./compiler/genunconverter";
|
|
import { sourceCodeFor } from "./compiler/value";
|
|
|
|
export function compile(env: M.Environment, schema: M.Schema, options: CompilerOptions = {}): string {
|
|
const mod = new ModuleContext(env, schema, options);
|
|
|
|
const embeddedName = schema.embeddedType;
|
|
mod.defineType(seq(`export type _embedded = `,
|
|
renderType(embeddedName._variant === 'false'
|
|
? Type.ref('any')
|
|
: typeForDefinition(mod, M.Definition.Pattern(M.Pattern.SimplePattern(M.SimplePattern.Ref(embeddedName.value))))),
|
|
`;`));
|
|
mod.defineType(`export type _val = _.Value<_embedded>;`);
|
|
|
|
for (const [name, def] of schema.definitions) {
|
|
const t = typeForDefinition(mod, def);
|
|
const nameStr = stringify(name);
|
|
|
|
mod.defineType(seq(`export type ${nameStr} = `, renderType(t), `;`));
|
|
|
|
if (t.kind === 'union') {
|
|
mod.defineFunction(_ctx =>
|
|
seq(`export namespace ${nameStr} `, block(
|
|
... Array.from(t.variants).map(([vn, vt]) =>
|
|
genConstructor(vn, vn, vt, nameStr))
|
|
)));
|
|
} else {
|
|
mod.defineFunction(_ctx =>
|
|
genConstructor(nameStr, void 0, t, nameStr));
|
|
}
|
|
}
|
|
|
|
for (const [name0, def] of schema.definitions) {
|
|
const name = name0 as symbol;
|
|
|
|
mod.defineFunction(ctx =>
|
|
seq(`export function as${name.description!}`,
|
|
'(v: _val): ', name.description!, ' ',
|
|
ctx.block(() => [
|
|
seq(`let result = to${name.description!}(v)`),
|
|
seq(`if (result === void 0) `,
|
|
`throw new TypeError(\`Invalid ${name.description!}: \${_.stringify(v)}\`)`),
|
|
seq(`return result`)])));
|
|
|
|
mod.defineFunction(ctx =>
|
|
seq(`export function to${name.description!}`,
|
|
'(v: _val): undefined | ', name.description!, ' ',
|
|
ctx.block(() => [seq(`let result: undefined | `, name.description!),
|
|
... converterForDefinition(ctx, def, 'v', 'result'),
|
|
seq(`return result`)])));
|
|
|
|
mod.defineFunction(ctx =>
|
|
seq(`export function from${name.description!}`,
|
|
'(_v: ', name.description!, '): _val ',
|
|
ctx.block(() => unconverterForDefinition(ctx, name.description!, def, '_v'))));
|
|
}
|
|
|
|
const f = new Formatter();
|
|
f.write(`import * as _ from ${JSON.stringify(options.preservesModule ?? '@preserves/core')};\n`);
|
|
mod.imports.forEach(([identifier, path]) => {
|
|
f.write(`import * as ${identifier} from ${JSON.stringify(path)};\n`);
|
|
});
|
|
f.newline();
|
|
|
|
const sortedLiterals = Array.from(mod.literals);
|
|
sortedLiterals.sort((a, b) => a[1] < b[1] ? -1 : a[1] === b[1] ? 0 : 1);
|
|
for (const [lit, varname] of sortedLiterals) {
|
|
f.write(seq(`export const ${varname} = `, sourceCodeFor(lit), `;\n`));
|
|
}
|
|
f.newline();
|
|
|
|
mod.typedefs.forEach(t => {
|
|
f.write(t);
|
|
f.newline();
|
|
f.newline();
|
|
});
|
|
f.newline();
|
|
|
|
mod.functiondefs.forEach(p => {
|
|
f.write(p);
|
|
f.newline();
|
|
f.newline();
|
|
});
|
|
|
|
return f.toString();
|
|
}
|