glen/math5
2
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

Reflect types into properties on top-level symbols as well. #4

Merged
glen merged 4 commits from feat/parse-reflection into feat/reflect-types 2024-10-21 16:58:00 +00:00
Conversation 0 Commits 4 Files Changed 6 +204 -122
4 changed files with 204 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 66bf2e281a - Show all commits

3
src/Complex/type.ts
View File

@ -17,7 +17,8 @@ export const Complex_type = {
(z: Complex<unknown>) => joinTypes(dep.typeOf(z.re), dep.typeOf(z.im)),
from: {
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) => ({re: t, im: dep.zero(t)})
}

2
src/index.ts
View File

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

2
tools/reflectTypes.mjs
View File

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

319
tools/ts2json.mjs
View File

@ -1,148 +1,229 @@
import * as ts from 'typescript'
const PROPERTY_TYPES = {
any: ts.SyntaxKind.AnyKeyword,
boolean: ts.SyntaxKind.BooleanKeyword,
number: ts.SyntaxKind.NumberKeyword,
string: ts.SyntaxKind.StringKeyword,
}
const intrinsicTypeKeywords = new Set([
ts.SyntaxKind.AnyKeyword,
ts.SyntaxKind.BooleanKeyword,
ts.SyntaxKind.NeverKeyword,
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 {
constructor(name, type) {
this.children = []
this.addChild = (name, type) => {
let node = new TSNode(name, type)
this.children.push(node)
return node
}
this.getType = () => this.type
this.getObject = () => {
let map = {}
map[this.name] = this.children.length
? this.children
.map(child => child.getObject())
.reduce((pv, child) => {
for (let key in child) {
if (pv.hasOwnProperty(key) || key in pv) {
if (child[key]) {
Object.assign(pv[key], child[key])
}
} else {
pv[key] = child[key]
}
}
return pv
}, {})
: this.type
return map
};
this.name = name
this.type = type
}
constructor(name, type) {
this.children = []
this.addChild = (name, type) => {
let node = new TSNode(name, type)
this.children.push(node)
return node
}
this.getType = () => this.type
this.getObject = () => {
let map = {}
map[this.name] = this.children.length
? this.children
.map(child => child.getObject())
.reduce((pv, child) => {
for (let key in child) {
if (pv.hasOwnProperty(key) || key in pv) {
if (child[key]) {
Object.assign(pv[key], child[key])
}
} else {
pv[key] = child[key]
}
}
return pv
}, {})
: this.type
return map
};
this.name = name
this.type = type
}
}
function parameterTypeStructure(paramNode, checker) {
let typeStruc = typeStructure(paramNode.type, checker)
if (paramNode.questionToken) typeStruc = {_optional: typeStruc}
return typeStruc
}
function typeStructure(typeNode, checker) {
switch (typeNode.kind) {
case ts.SyntaxKind.IntersectionType:
return {
switch (typeNode.kind) {
case ts.SyntaxKind.UnionType:
return {
_union: typeNode.types.map(t => typeStructure(t, checker))
}
case ts.SyntaxKind.IntersectionType:
return {
_intersection: typeNode.types.map(t => typeStructure(t, checker))
}
case ts.SyntaxKind.ImportType:
return {
}
case ts.SyntaxKind.ImportType: {
const typeStruc = {
_importedFrom: typeNode.argument.literal.text,
_name: typeNode.qualifier.text
}
case ts.SyntaxKind.TypeLiteral:
return Object.fromEntries(typeNode.members.map(
}
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(
mem => [mem.name.text, typeStructure(mem.type, checker)]))
case ts.SyntaxKind.FunctionType:
return {
case ts.SyntaxKind.FunctionType: {
const typeStruc = {
_parameters: typeNode.parameters.map(
p => typeStructure(p.type, checker)),
p => parameterTypeStructure(p, checker)),
_returns: typeStructure(typeNode.type, checker)
}
case ts.SyntaxKind.LiteralType:
return checker.typeToString(checker.getTypeFromTypeNode(typeNode))
default:
console.log('I See', ts.SyntaxKind[typeNode.kind])
}
return checker.getTypeFromTypeNode(typeNode).intrinsicName
}
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:
return checker.typeToString(checker.getTypeFromTypeNode(typeNode))
default:
if (intrinsicTypeKeywords.has(typeNode.kind)) {
return checker.getTypeFromTypeNode(typeNode).intrinsicName
}
}
throw new Error(`Unhandled type node ${ts.SyntaxKind[typeNode.kind]}`)
}
const visit = (parent, checker) => node => {
switch (node.kind) {
case ts.SyntaxKind.ImportDeclaration:
console.log('Skipping import from', node.moduleSpecifier.text)
break
console.log('Skipping import from', node.moduleSpecifier.text)
break
case ts.SyntaxKind.VariableStatement:
console.log('Processing variable',
ts.SyntaxKind[node.declarationList.kind])
node.declarationList.declarations.forEach(visit(parent, checker))
console.log('Done with variable')
break
case ts.SyntaxKind.VariableDeclaration:
console.log('Processing var dec', node.name.text, 'in', parent)
const typeStruc = typeStructure(node.type, checker)
console.log('Type is', typeStructure(node.type, checker))
if ('_intersection' in typeStruc) {
console.log('First type is', typeStruc._intersection[0])
console.log('Processing variable',
ts.SyntaxKind[node.declarationList.kind])
node.declarationList.declarations.forEach(visit(parent, checker))
console.log('Done with variable')
break
case ts.SyntaxKind.VariableDeclaration: {
console.log('Processing var dec', node.name.text)
const typeStruc = typeStructure(node.type, checker)
parent.addChild(node.name.text, typeStruc)
break
}
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)
break
}
parent.addChild(node.name.text, typeStruc)
break
case ts.SyntaxKind.ModuleDeclaration:
let moduleName = node.name.text
console.log('Declaring', moduleName)
ts.forEachChild(node, visit(parent.addChild(moduleName), checker))
break
let moduleName = node.name.text
console.log('Declaring', moduleName)
ts.forEachChild(node, visit(parent.addChild(moduleName), checker))
break
case ts.SyntaxKind.ModuleBlock:
console.log('Block')
ts.forEachChild(node, visit(parent, checker));
break
console.log('Block')
ts.forEachChild(node, visit(parent, checker));
break
case ts.SyntaxKind.InterfaceDeclaration:
let interfaceName = node.name.text
console.log('Skipping Interface', interfaceName);
break
parent[interfaceName] = {}
ts.forEachChild(node, visit(parent.addChild(interfaceName), checker))
break
let interfaceName = node.name.text
console.log('Skipping Interface', interfaceName);
break
parent[interfaceName] = {}
ts.forEachChild(node, visit(parent.addChild(interfaceName), checker))
break
case ts.SyntaxKind.PropertySignature:
let propertyName = node.name
let propertyType = node.type
let arrayDeep = 0
let realPropertyName =
'string' !== typeof propertyName && 'text' in propertyName
? propertyName.text
: propertyName
console.log('Property', realPropertyName)
while (propertyType.kind === ts.SyntaxKind.ArrayType) {
arrayDeep++
propertyType = propertyType.elementType
}
if (propertyType.kind === ts.SyntaxKind.TypeReference) {
let realPropertyType = propertyType.typeName
parent.addChild(
let propertyName = node.name
let propertyType = node.type
let arrayDeep = 0
let realPropertyName =
'string' !== typeof propertyName && 'text' in propertyName
? propertyName.text
: propertyName
console.log('Property', realPropertyName)
while (propertyType.kind === ts.SyntaxKind.ArrayType) {
arrayDeep++
propertyType = propertyType.elementType
}
if (propertyType.kind === ts.SyntaxKind.TypeReference) {
let realPropertyType = propertyType.typeName
parent.addChild(
realPropertyName,
'Array<'.repeat(arrayDeep) +
(realPropertyType.kind === ts.SyntaxKind.QualifiedName
? realPropertyType.getText()
: 'text' in realPropertyType
? realPropertyType.text
: realPropertyType) +
'>'.repeat(arrayDeep)
)
} else {
if (intrinsicTypeKeywords.has(propertyType.kind)) {
parent.addChild(
realPropertyName,
'Array<'.repeat(arrayDeep) +
(realPropertyType.kind === ts.SyntaxKind.QualifiedName
? realPropertyType.getText()
: 'text' in realPropertyType
? realPropertyType.text
: realPropertyType) +
'>'.repeat(arrayDeep)
)
} else {
for (let type in PROPERTY_TYPES) {
if (propertyType.kind === PROPERTY_TYPES[type]) {
parent.addChild(realPropertyName, type)
break
}
}
}
break
checker.getTypeFromTypeNode(propertyType).intrinsicName)
}
}
break
case ts.SyntaxKind.EndOfFileToken:
console.log('File ended.')
break
default:
console.warn(
'Unhandled node kind',
node.kind, ts.SyntaxKind[node.kind])
console.warn(
'Unhandled node kind',
node.kind, ts.SyntaxKind[node.kind])
}
}