136 lines
2.9 KiB
TypeScript
136 lines
2.9 KiB
TypeScript
import {
|
|
createAst,
|
|
DirectiveRule,
|
|
FunctionRule,
|
|
ImportRule,
|
|
LinkRule,
|
|
NamespaceRule,
|
|
Rule,
|
|
VariableRule
|
|
} from './createAst.js'
|
|
import path from 'path';
|
|
import debug from 'debug';
|
|
import { createRequire } from 'module';
|
|
import { pathToFileURL } from 'url';
|
|
const log = debug('vogue:module');
|
|
|
|
export type LinkDescription = {
|
|
name: string,
|
|
array: boolean,
|
|
required: boolean
|
|
};
|
|
|
|
export type Variable = {
|
|
name: string,
|
|
persist: boolean
|
|
}
|
|
|
|
export default class Module {
|
|
links: LinkDescription[] = [];
|
|
globals = [];
|
|
functions: {
|
|
[name: string]: {
|
|
code: string,
|
|
async: boolean,
|
|
parameters: string[]
|
|
}
|
|
} = {};
|
|
identifiers: {
|
|
[name: string]: Rule["type"]
|
|
} = {};
|
|
name = {
|
|
space: '',
|
|
last: '',
|
|
full: ''
|
|
};
|
|
imports: {
|
|
[key: string]: any
|
|
} = {};
|
|
variables: Variable[] = [];
|
|
// directives
|
|
'singleton': boolean = false;
|
|
'keepalive': boolean = false;
|
|
'static': string = '';
|
|
// other stuff
|
|
rootDir: string = '';
|
|
|
|
async directive({ directive, value }: DirectiveRule): Promise<void> {
|
|
if (typeof this[directive] === 'boolean')
|
|
(this[directive] as boolean) = value as boolean;
|
|
else if (typeof this[directive] === 'string')
|
|
(this[directive] as string) = value as string;
|
|
// = value as string;
|
|
}
|
|
|
|
async link({ required, array, name }: LinkRule): Promise<void> {
|
|
this.links.push({
|
|
name,
|
|
required,
|
|
array
|
|
});
|
|
}
|
|
|
|
async namespace({ namespace }: NamespaceRule): Promise<void> {
|
|
this.name.space = namespace;
|
|
this.name.full = this.name.space + '.' + this.name.last;
|
|
}
|
|
|
|
async function({ name, block, parameters, async }: FunctionRule): Promise<void> {
|
|
this.functions[name] = {
|
|
code: block,
|
|
parameters,
|
|
async
|
|
};
|
|
}
|
|
|
|
async import({ importName, name }: ImportRule): Promise<void> {
|
|
const nodePath = path.resolve(this.rootDir, 'node_module');
|
|
const __require__ = createRequire(nodePath);
|
|
const imported = __require__(importName);
|
|
if ('default' in imported) this.imports[name] = imported.default;
|
|
else this.imports[name] = imported;
|
|
}
|
|
|
|
async variable({ persist, name }: VariableRule): Promise<void> {
|
|
this.variables.push({
|
|
name,
|
|
persist
|
|
});
|
|
}
|
|
|
|
static async create(location: string, rootDir: string) {
|
|
const module = new Module();
|
|
const ast = createAst(location);
|
|
const name = path.parse(location).name;
|
|
|
|
module.name.last = name;
|
|
module.name.full = name;
|
|
module.rootDir = rootDir;
|
|
|
|
for (const item of ast) {
|
|
if ('name' in item) {
|
|
if (item.name in module.identifiers)
|
|
throw new Error('Identifier ' + item.name + ' already declared!');
|
|
else {
|
|
module.identifiers[item.name] = item.type;
|
|
}
|
|
}
|
|
|
|
log(`processing AST Rule (${'name' in item ? name + '|' : '' }${item.type})`);
|
|
// log(item);
|
|
|
|
if (item.type in module) {
|
|
const func = module[item.type] as ((arg0: Rule) => Promise<void>)
|
|
func.call(module, item);
|
|
}
|
|
}
|
|
|
|
log('='.repeat(80));
|
|
log(location);
|
|
log(module);
|
|
|
|
return module;
|
|
}
|
|
}
|
|
|