daton/lib/src/unit/Canonical.ts

import LifecycleUnit from '../lifecycle/Unit.ts'
import {fs, path} from '../external/std.ts'
import {Canon} from './Canon.ts'

export interface CanonicalDefinition {
    canonical_name: string,
    original_name: string,
    imported: any,
}

export class Canonical<T> extends LifecycleUnit {
    protected base_path: string = '.'
    protected suffix: string = '.ts'
    protected canonical_item: string = ''
    protected _items: { [key: string]: T } = {}

    public get path(): string {
        return path.resolve(this.base_path)
    }

    public get canonical_items() {
        return `${this.canonical_item}s`
    }

    public async up() {
        for await ( const entry of fs.walk(this.path) ) {
            if ( !entry.isFile || !entry.path.endsWith(this.suffix) ) continue
            const def = await this._get_canonical_definition(entry.path)
            this._items[def.canonical_name] = await this.init_canonical_item(def)
        }

        this.make(Canon).register_resource(this.canonical_items, (key: string) => this.get(key))
    }

    public async init_canonical_item(definition: CanonicalDefinition): Promise<T> {
        return definition.imported.default
    }

    private async _get_canonical_definition(file_path: string): Promise<CanonicalDefinition> {
        const original_name = file_path.replace(this.path, '').substr(1)
        const path_regex = new RegExp(path.SEP, 'g')
        const canonical_name = original_name.replace(path_regex, ':')
            .split('').reverse().join('')
            .substr(this.suffix.length)
            .split('').reverse().join('')
        const imported = await import(file_path)
        return { canonical_name, original_name, imported }
    }

    public get(key: string): T | undefined {
        return this._items[key]
    }
}