feat: Extend type injection to all exported values

This commit is contained in:
Glen Whitney 2024-10-17 22:20:44 -07:00
parent d5b4ccfc2a
commit 66bf2e281a
4 changed files with 204 additions and 122 deletions

View File

@ -17,7 +17,8 @@ export const Complex_type = {
(z: Complex<unknown>) => joinTypes(dep.typeOf(z.re), dep.typeOf(z.im)), (z: Complex<unknown>) => joinTypes(dep.typeOf(z.re), dep.typeOf(z.im)),
from: { from: {
Complex: <U,T>(dep: {convert: CommonSignature<U,T>['convert']}) => Complex: <U,T>(dep: {convert: CommonSignature<U,T>['convert']}) =>
(z: Complex<U>) => ({re: dep.convert(z.re), im: dep.convert(z.im)}), (z: Complex<U>): Complex<T> =>
({re: dep.convert(z.re), im: dep.convert(z.im)}),
T: <T>(dep: {zero: CommonSignature<T>['zero']}) => T: <T>(dep: {zero: CommonSignature<T>['zero']}) =>
(t: T) => ({re: t, im: dep.zero(t)}) (t: T) => ({re: t, im: dep.zero(t)})
} }

View File

@ -2,4 +2,4 @@ import {inspect} from 'node:util'
import * as specifications from './all' import * as specifications from './all'
console.log(inspect(specifications, {depth: 10, colors: true})) console.log(inspect(specifications, {depth: 18, colors: true}))

View File

@ -49,7 +49,7 @@ function reflectType5(srcFile, options = { debug: false }) {
for (const id in parsedDefs) { for (const id in parsedDefs) {
if (id.includes('interface')) continue if (id.includes('interface')) continue
srcReflected += srcReflected +=
`\n${id}.reflectedType6 = ${JSON.stringify(parsedDefs[id])}\n` `\n${id}._reflectedType6 = ${JSON.stringify(parsedDefs[id])}\n`
} }
writeFileSync(srcFile, srcReflected) writeFileSync(srcFile, srcReflected)

View File

@ -1,11 +1,21 @@
import * as ts from 'typescript' import * as ts from 'typescript'
const PROPERTY_TYPES = { const intrinsicTypeKeywords = new Set([
any: ts.SyntaxKind.AnyKeyword, ts.SyntaxKind.AnyKeyword,
boolean: ts.SyntaxKind.BooleanKeyword, ts.SyntaxKind.BooleanKeyword,
number: ts.SyntaxKind.NumberKeyword, ts.SyntaxKind.NeverKeyword,
string: ts.SyntaxKind.StringKeyword, ts.SyntaxKind.NumberKeyword,
} ts.SyntaxKind.StringKeyword,
ts.SyntaxKind.UndefinedKeyword,
ts.SyntaxKind.UnknownKeyword,
ts.SyntaxKind.VoidKeyword
])
const typeOperatorKeywords = new Map([
[ts.SyntaxKind.KeyofKeyword, '_keyof'],
[ts.SyntaxKind.ReadonlyKeyword, '_readonly'],
[ts.SyntaxKind.UniqueKeyword, '_unique'],
])
class TSNode { class TSNode {
constructor(name, type) { constructor(name, type) {
@ -41,33 +51,91 @@ class TSNode {
} }
} }
function parameterTypeStructure(paramNode, checker) {
let typeStruc = typeStructure(paramNode.type, checker)
if (paramNode.questionToken) typeStruc = {_optional: typeStruc}
return typeStruc
}
function typeStructure(typeNode, checker) { function typeStructure(typeNode, checker) {
switch (typeNode.kind) { switch (typeNode.kind) {
case ts.SyntaxKind.UnionType:
return {
_union: typeNode.types.map(t => typeStructure(t, checker))
}
case ts.SyntaxKind.IntersectionType: case ts.SyntaxKind.IntersectionType:
return { return {
_intersection: typeNode.types.map(t => typeStructure(t, checker)) _intersection: typeNode.types.map(t => typeStructure(t, checker))
} }
case ts.SyntaxKind.ImportType: case ts.SyntaxKind.ImportType: {
return { const typeStruc = {
_importedFrom: typeNode.argument.literal.text, _importedFrom: typeNode.argument.literal.text,
_name: typeNode.qualifier.text _name: typeNode.qualifier.text
} }
case ts.SyntaxKind.TypeLiteral: if (typeNode.typeArguments) {
typeStruc._typeArguments = typeNode.typeArguments.map(
p => typeStructure(p, checker))
}
return typeStruc
}
case ts.SyntaxKind.ArrayType:
return {_array: typeStructure(typeNode.elementType, checker)}
case ts.SyntaxKind.TypeLiteral: // Seems to be plain object types
return Object.fromEntries(typeNode.members.map( return Object.fromEntries(typeNode.members.map(
mem => [mem.name.text, typeStructure(mem.type, checker)])) mem => [mem.name.text, typeStructure(mem.type, checker)]))
case ts.SyntaxKind.FunctionType: case ts.SyntaxKind.FunctionType: {
return { const typeStruc = {
_parameters: typeNode.parameters.map( _parameters: typeNode.parameters.map(
p => typeStructure(p.type, checker)), p => parameterTypeStructure(p, checker)),
_returns: typeStructure(typeNode.type, checker) _returns: typeStructure(typeNode.type, checker)
} }
if (typeNode.typeParameters) {
typeStruc._typeParameters = typeNode.typeParameters.map(
p => p.name.text)
}
return typeStruc
}
case ts.SyntaxKind.IndexedAccessType:
return {
_ofType: typeStructure(typeNode.objectType, checker),
_index: typeStructure(typeNode.indexType, checker)
}
case ts.SyntaxKind.TypeOperator:
console.log('structuring operator', typeNode)
const key = typeOperatorKeywords.get(
typeNode.operator,
'_unidentified_operator'
)
return {
[key]:
typeStructure(typeNode.type, checker)
}
case ts.SyntaxKind.ConditionalType:
return {
_subtype: typeStructure(typeNode.checkType, checker),
_basetype: typeStructure(typeNode.extendsType, checker),
_truetype: typeStructure(typeNode.trueType, checker),
_falsetype: typeStructure(typeNode.falseType, checker),
}
case ts.SyntaxKind.TypeReference: {
const typeStruc = {_typeParameter: typeNode.typeName.text}
if (typeNode.typeArguments) {
typeStruc._typeArguments = typeNode.typeArguments.map(
arg => typeStructure(arg, checker))
}
return typeStruc
}
case ts.SyntaxKind.TypePredicate:
return {_is: typeStructure(typeNode.type, checker)}
case ts.SyntaxKind.LiteralType: case ts.SyntaxKind.LiteralType:
return checker.typeToString(checker.getTypeFromTypeNode(typeNode)) return checker.typeToString(checker.getTypeFromTypeNode(typeNode))
default: default:
console.log('I See', ts.SyntaxKind[typeNode.kind]) if (intrinsicTypeKeywords.has(typeNode.kind)) {
}
return checker.getTypeFromTypeNode(typeNode).intrinsicName return checker.getTypeFromTypeNode(typeNode).intrinsicName
} }
}
throw new Error(`Unhandled type node ${ts.SyntaxKind[typeNode.kind]}`)
}
const visit = (parent, checker) => node => { const visit = (parent, checker) => node => {
switch (node.kind) { switch (node.kind) {
@ -80,15 +148,26 @@ const visit = (parent, checker) => node => {
node.declarationList.declarations.forEach(visit(parent, checker)) node.declarationList.declarations.forEach(visit(parent, checker))
console.log('Done with variable') console.log('Done with variable')
break break
case ts.SyntaxKind.VariableDeclaration: case ts.SyntaxKind.VariableDeclaration: {
console.log('Processing var dec', node.name.text, 'in', parent) console.log('Processing var dec', node.name.text)
const typeStruc = typeStructure(node.type, checker) const typeStruc = typeStructure(node.type, checker)
console.log('Type is', typeStructure(node.type, checker)) parent.addChild(node.name.text, typeStruc)
if ('_intersection' in typeStruc) { break
console.log('First type is', typeStruc._intersection[0]) }
case ts.SyntaxKind.FunctionDeclaration: {
console.log('Processing func dec', node.name.text)
const typeStruc = {
_parameters: node.parameters.map(
p => parameterTypeStructure(p, checker)),
_returns: typeStructure(node.type, checker)
}
if (node.typeParameters) {
typeStruc._typeParameters = node.typeParameters.map(
p => p.name.text)
} }
parent.addChild(node.name.text, typeStruc) parent.addChild(node.name.text, typeStruc)
break break
}
case ts.SyntaxKind.ModuleDeclaration: case ts.SyntaxKind.ModuleDeclaration:
let moduleName = node.name.text let moduleName = node.name.text
console.log('Declaring', moduleName) console.log('Declaring', moduleName)
@ -131,13 +210,15 @@ const visit = (parent, checker) => node => {
'>'.repeat(arrayDeep) '>'.repeat(arrayDeep)
) )
} else { } else {
for (let type in PROPERTY_TYPES) { if (intrinsicTypeKeywords.has(propertyType.kind)) {
if (propertyType.kind === PROPERTY_TYPES[type]) { parent.addChild(
parent.addChild(realPropertyName, type) realPropertyName,
checker.getTypeFromTypeNode(propertyType).intrinsicName)
}
}
break break
} case ts.SyntaxKind.EndOfFileToken:
} console.log('File ended.')
}
break break
default: default:
console.warn( console.warn(