@htmlplus/element 2.11.0 → 2.13.0

package/transformer/transformer.js

@@ -1,78 +0,0 @@
-import ora from 'ora';
-import path from 'path';
-const logger = ora({
-    color: 'yellow'
-});
-const log = (message, persist) => {
-    const content = `${new Date().toLocaleTimeString()} [HTMLPLUS] ${message}`;
-    const log = logger.start(content);
-    if (!persist)
-        return;
-    log.succeed();
-};
-export const transformer = (...plugins) => {
-    let global = {
-        contexts: []
-    };
-    const start = async () => {
-        log(`Started.`, true);
-        log(`${plugins.length} plugins found.`, true);
-        log(`Plugins are starting.`, true);
-        for (const plugin of plugins) {
-            if (!plugin.start)
-                continue;
-            log(`Plugin '${plugin.name}' is starting.`);
-            global = (await plugin.start(global)) || global;
-            log(`Plugin '${plugin.name}' started successfully.`);
-        }
-        log(`Plugins started successfully.`, true);
-    };
-    const run = async (filePath) => {
-        const key = path.join(filePath).split(path.sep).pop();
-        let context = {
-            filePath
-        };
-        const parsed = path.parse(filePath);
-        for (const plugin of plugins) {
-            if (!plugin.run)
-                continue;
-            const source = path.join(parsed.dir).split(path.sep).slice(-2).concat(parsed.base).join('/');
-            log(`Plugin '${plugin.name}' is executing on '${source}' file.`);
-            try {
-                context = (await plugin.run(context, global)) || context;
-            }
-            catch (error) {
-                log(`Error in '${plugin.name}' plugin on '${source}' file.\n`, true);
-                throw error;
-            }
-            global.contexts = global.contexts
-                .filter((current) => {
-                return current.filePath != context.filePath;
-            })
-                .concat(context);
-            log(`Plugin '${plugin.name}' executed successfully on '${source}' file.`);
-        }
-        logger.stop();
-        return context;
-    };
-    const finish = async () => {
-        log(`Plugins are finishing.`, true);
-        for (const plugin of plugins) {
-            if (!plugin.finish)
-                continue;
-            log(`Plugin '${plugin.name}' is finishing.`);
-            global = (await plugin.finish(global)) || global;
-            log(`Plugin '${plugin.name}' finished successfully.`);
-        }
-        log(`Plugins finished successfully.`, true);
-        log(`Finished.`, true);
-    };
-    const write = async () => {
-        for (const plugin of plugins) {
-            if (!plugin.write)
-                continue;
-            global = (await plugin.write(global)) || global;
-        }
-    };
-    return { global, start, run, finish, write };
-};

package/transformer/transformer.types.d.ts

@@ -1,52 +0,0 @@
-import { ClassBody, ClassDeclaration, ClassMethod, ClassProperty, File } from '@babel/types';
-type Return<T> = void | T | Promise<void | T>;
-export interface TransformerPluginContext {
-    skipped?: boolean;
-    script?: string;
-    assetsDestination?: string;
-    assetsSource?: string;
-    class?: ClassDeclaration;
-    classEvents?: Array<ClassProperty>;
-    classMembers?: ClassBody['body'];
-    classMethods?: Array<ClassMethod>;
-    className?: string;
-    classProperties?: Array<ClassProperty>;
-    classStates?: Array<ClassProperty>;
-    directoryName?: string;
-    directoryPath?: string;
-    elementKey?: string;
-    elementInterfaceName?: string;
-    elementTagName?: string;
-    fileAST?: File;
-    fileContent?: string;
-    fileExtension?: string;
-    fileName?: string;
-    filePath?: string;
-    metadata?: {
-        [key: string]: any;
-    };
-    readmeContent?: string;
-    readmeExtension?: string;
-    readmeName?: string;
-    readmePath?: string;
-    styleContent?: string;
-    styleContentTransformed?: string;
-    styleExtension?: string;
-    styleName?: string;
-    stylePath?: string;
-}
-export interface TransformerPluginGlobal {
-    contexts: Array<TransformerPluginContext>;
-    metadata?: {
-        [key: string]: any;
-    };
-}
-export interface TransformerPlugin {
-    name: string;
-    options?: any;
-    start?: (global: TransformerPluginGlobal) => Return<TransformerPluginGlobal>;
-    run?: (context: TransformerPluginContext, global: TransformerPluginGlobal) => Return<TransformerPluginContext>;
-    finish?: (global: TransformerPluginGlobal) => Return<TransformerPluginGlobal>;
-    write?: (global: TransformerPluginGlobal) => Return<TransformerPluginGlobal>;
-}
-export {};

package/transformer/transformer.types.js

@@ -1 +0,0 @@
-export {};

package/transformer/utils/addDependency.d.ts

@@ -1,7 +0,0 @@
-import t from '@babel/types';
-interface AddDependencyReturns {
-    local?: string;
-    node: t.ImportDeclaration;
-}
-export declare function addDependency(path: t.File | any, source: string, local?: string, imported?: string, comment?: boolean): AddDependencyReturns;
-export {};

package/transformer/utils/addDependency.js

@@ -1,64 +0,0 @@
-import t from '@babel/types';
-import * as CONSTANTS from '../../constants/index.js';
-import { visitor } from './visitor.js';
-export function addDependency(path, source, local, imported, comment) {
-    const isDefault = local && !imported;
-    const isImport = local && imported;
-    const isNormal = !local && !imported;
-    let declaration;
-    let file = path;
-    while (file.parentPath)
-        file = file.parentPath;
-    file = file.node || file;
-    visitor(file, {
-        ImportDeclaration(path) {
-            if (path.node.source.value != source)
-                return;
-            declaration = path.node;
-        }
-    });
-    if (isNormal && declaration)
-        return {
-            node: declaration
-        };
-    let specifier = declaration?.specifiers.find((specifier) => {
-        if (isDefault) {
-            return specifier.type == 'ImportDefaultSpecifier';
-        }
-        else if (isImport) {
-            return specifier.imported?.name == imported;
-        }
-    });
-    if (specifier)
-        return {
-            local: specifier.local.name,
-            node: declaration
-        };
-    if (isDefault) {
-        specifier = t.importDefaultSpecifier(t.identifier(local));
-    }
-    else if (isImport) {
-        specifier = t.importSpecifier(t.identifier(local), t.identifier(imported));
-    }
-    if (declaration) {
-        if (isDefault) {
-            declaration.specifiers.unshift(specifier);
-        }
-        else if (isImport) {
-            declaration.specifiers.push(specifier);
-        }
-    }
-    else {
-        declaration = t.importDeclaration(specifier ? [specifier] : [], t.stringLiteral(source));
-        // TODO
-        (file.program || file).body.unshift(declaration);
-        // TODO
-        if (comment) {
-            t.addComment(declaration, 'leading', CONSTANTS.COMMENT_AUTO_ADDED, true);
-        }
-    }
-    return {
-        local,
-        node: declaration
-    };
-}

package/transformer/utils/extractAttribute.d.ts

@@ -1,2 +0,0 @@
-import t from '@babel/types';
-export declare const extractAttribute: (property: t.ClassProperty) => string | undefined;

package/transformer/utils/extractAttribute.js

@@ -1,10 +0,0 @@
-import * as CONSTANTS from '../../constants/index.js';
-export const extractAttribute = (property) => {
-    try {
-        return property.decorators
-            .find((decorator) => decorator.expression.callee.name == CONSTANTS.DECORATOR_PROPERTY)
-            .expression.arguments[0].properties.find((property) => property.key.name == 'attribute').value
-            .value;
-    }
-    catch { }
-};

package/transformer/utils/extractFromComment.d.ts

@@ -1,4 +0,0 @@
-import t from '@babel/types';
-export declare const extractFromComment: (node: t.Node, whitelist?: string[]) => {
-    [key: string]: any;
-};

package/transformer/utils/extractFromComment.js

@@ -1,51 +0,0 @@
-export const extractFromComment = (node, whitelist) => {
-    const normalized = [];
-    const result = {
-        description: ''
-    };
-    const lines = node.leadingComments
-        ?.map((comment) => {
-        if (comment.type == 'CommentLine')
-            return comment.value;
-        return comment.value.split('\n');
-    })
-        ?.flat()
-        ?.map((line) => line.trim().replace(/^\*/, '').trim())
-        ?.filter((line) => line.trim());
-    for (const line of lines || []) {
-        if (line.startsWith('@')) {
-            normalized.push(line);
-            continue;
-        }
-        if (!normalized.length)
-            normalized.push('');
-        normalized[normalized.length - 1] += ' ' + line;
-    }
-    for (const line of normalized) {
-        if (!line.startsWith('@')) {
-            result.description = line.trim();
-            continue;
-        }
-        const regex = /@(\w+)(?:\s*({\w+})\s*)?(?:\s*([-a-zA-Z\s]+)\s*-\s*)?(.*)/;
-        const groups = regex.exec(line);
-        if (!groups)
-            continue;
-        const tag = groups[1]?.trim();
-        const type = groups[2]?.trim().slice(1, -1);
-        const name = groups[3]?.trim();
-        const description = groups[4]?.trim();
-        if (name && description) {
-            const key = tag + 's';
-            if (whitelist && !whitelist.includes(key))
-                continue;
-            (result[key] ||= []).push({ name, type, description });
-        }
-        else {
-            const key = tag;
-            if (whitelist && !whitelist.includes(key))
-                continue;
-            result[key] = description || true;
-        }
-    }
-    return result;
-};

package/transformer/utils/getInitializer.d.ts

@@ -1,2 +0,0 @@
-import t from '@babel/types';
-export declare const getInitializer: (node: t.Expression) => string | undefined;

package/transformer/utils/getInitializer.js

@@ -1,3 +0,0 @@
-export const getInitializer = (node) => {
-    return node?.extra?.raw || node?.['value'];
-};

package/transformer/utils/getType.d.ts

@@ -1,2 +0,0 @@
-import t from '@babel/types';
-export declare const getType: (directory: string, file: t.File, node: t.Node) => t.Node;

package/transformer/utils/getType.js

@@ -1,89 +0,0 @@
-import { parse } from '@babel/parser';
-import fs from 'fs-extra';
-import { glob } from 'glob';
-import { dirname, resolve } from 'path';
-import { join } from 'path';
-import { visitor } from './visitor.js';
-export const getType = (directory, file, node) => {
-    if (!node)
-        return node;
-    if (node.type != 'TSTypeReference')
-        return node;
-    let result;
-    visitor(file, {
-        ClassDeclaration(path) {
-            if (path.node.id.name != node.typeName['name'])
-                return;
-            result = path.node;
-            path.stop();
-        },
-        ImportDeclaration(path) {
-            for (const specifier of path.node.specifiers) {
-                const alias = specifier.local.name;
-                if (alias != node.typeName['name'])
-                    continue;
-                let key;
-                switch (specifier.type) {
-                    case 'ImportNamespaceSpecifier':
-                        key = '*';
-                        break;
-                    case 'ImportDefaultSpecifier':
-                        key = 'default';
-                        break;
-                    case 'ImportSpecifier':
-                        key = specifier.imported.name;
-                        break;
-                }
-                try {
-                    const reference = glob
-                        .sync(['.ts*', '/index.ts*'].map((key) => {
-                        return join(directory, path.node.source.value).replace(/\\/g, '/') + key;
-                    }))
-                        .find((reference) => fs.existsSync(reference));
-                    const content = fs.readFileSync(reference, 'utf8');
-                    const filePath = resolve(directory, path.node.source.value + '.ts');
-                    path.$ast ||= parse(content, {
-                        allowImportExportEverywhere: true,
-                        plugins: ['typescript'],
-                        ranges: false
-                    });
-                    result = getType(dirname(filePath), path.$ast, node);
-                }
-                catch { }
-                path.stop();
-                break;
-            }
-        },
-        TSInterfaceDeclaration(path) {
-            if (path.node.id.name != node.typeName['name'])
-                return;
-            result = path.node;
-            path.stop();
-        },
-        TSTypeAliasDeclaration(path) {
-            if (path.node.id.name != node.typeName['name'])
-                return;
-            result = path.node.typeAnnotation;
-            switch (result.type) {
-                case 'TSUnionType':
-                    const types = [];
-                    for (const prev of result.types) {
-                        const next = getType(directory, file, prev);
-                        if (next.type == 'TSUnionType') {
-                            next.types.forEach((type) => types.push(type));
-                        }
-                        else {
-                            types.push(next);
-                        }
-                    }
-                    result.types = types;
-                    break;
-                default:
-                    result = getType(directory, file, result);
-                    break;
-            }
-            path.stop();
-        }
-    });
-    return result || node;
-};

package/transformer/utils/getTypeReference.d.ts

@@ -1,2 +0,0 @@
-import { File, Node } from '@babel/types';
-export declare const getTypeReference: (file: File, node: Node) => string | undefined;

package/transformer/utils/getTypeReference.js

@@ -1,33 +0,0 @@
-import { visitor } from './visitor.js';
-export const getTypeReference = (file, node) => {
-    if (!node)
-        return;
-    if (node.type != 'TSTypeReference')
-        return;
-    let result;
-    visitor(file, {
-        ImportDeclaration(path) {
-            for (const specifier of path.node.specifiers) {
-                const alias = specifier.local.name;
-                if (alias != node.typeName['name'])
-                    continue;
-                let key;
-                switch (specifier.type) {
-                    case 'ImportNamespaceSpecifier':
-                        key = '*';
-                        break;
-                    case 'ImportDefaultSpecifier':
-                        key = 'default';
-                        break;
-                    case 'ImportSpecifier':
-                        key = specifier.imported.name;
-                        break;
-                }
-                result = path.node.source.value;
-                path.stop();
-                break;
-            }
-        }
-    });
-    return result;
-};

package/transformer/utils/hasDecorator.d.ts

@@ -1 +0,0 @@
-export declare const hasDecorator: (node: any, name: string) => boolean;

package/transformer/utils/hasDecorator.js

@@ -1,5 +0,0 @@
-export const hasDecorator = (node, name) => {
-    if (!node.decorators)
-        return false;
-    return !!node.decorators.some((decorator) => decorator.expression.callee?.name == name);
-};

package/transformer/utils/index.d.ts

@@ -1,10 +0,0 @@
-export * from './addDependency.js';
-export * from './extractAttribute.js';
-export * from './extractFromComment.js';
-export * from './getInitializer.js';
-export * from './getType.js';
-export * from './getTypeReference.js';
-export * from './hasDecorator.js';
-export * from './printType.js';
-export * from './print.js';
-export * from './visitor.js';

package/transformer/utils/index.js

@@ -1,10 +0,0 @@
-export * from './addDependency.js';
-export * from './extractAttribute.js';
-export * from './extractFromComment.js';
-export * from './getInitializer.js';
-export * from './getType.js';
-export * from './getTypeReference.js';
-export * from './hasDecorator.js';
-export * from './printType.js';
-export * from './print.js';
-export * from './visitor.js';

package/transformer/utils/print.d.ts

@@ -1,2 +0,0 @@
-import { Node } from '@babel/types';
-export declare const print: (ast: Node) => string;

package/transformer/utils/print.js

@@ -1,5 +0,0 @@
-import generator from '@babel/generator';
-// TODO: add options
-export const print = (ast) => {
-    return (generator.default || generator)(ast, { decoratorsBeforeExport: true }).code;
-};

package/transformer/utils/printType.d.ts

@@ -1 +0,0 @@
-export declare const printType: (ast: any) => any;

package/transformer/utils/printType.js

@@ -1,69 +0,0 @@
-import { print } from './print.js';
-// TODO
-// args types
-// return type
-// elements\grid-item\grid-item.types.ts
-// elements\portal\portal.tsx
-export const printType = (ast) => {
-    if (!ast)
-        return ast;
-    let result = {};
-    switch (ast.type) {
-        case 'BooleanLiteral':
-        case 'NumericLiteral':
-        case 'StringLiteral': {
-            result.key = ast.value;
-            result.type = ast.type.replace('Literal', '').toLowerCase();
-            break;
-        }
-        case 'TSBooleanKeyword':
-        case 'TSNumberKeyword':
-        case 'TSStringKeyword': {
-            const type = ast.type.replace('TS', '').replace('Keyword', '').toLowerCase();
-            result.key = type;
-            result.type = type;
-            break;
-        }
-        case 'TSAnyKeyword': {
-            result.type = 'any';
-            break;
-        }
-        case 'TSArrayType': {
-            const type = print(ast.elementType) + '[]';
-            result.key = type;
-            result.type = type;
-            break;
-        }
-        case 'TSInterfaceDeclaration': {
-            result.type = ast.id.name;
-            result.members = ast.body.body.map((body) => printType(body));
-            break;
-        }
-        case 'TSLiteralType': {
-            result = printType(ast.literal);
-            break;
-        }
-        case 'TSPropertySignature': {
-            const { typeAnnotation } = ast;
-            result.key = ast.key.name;
-            if (typeAnnotation && typeAnnotation.typeAnnotation)
-                result.type = printType(ast.typeAnnotation.typeAnnotation).type;
-            break;
-        }
-        case 'TSTypeAliasDeclaration': {
-            result = printType(ast.typeAnnotation);
-            break;
-        }
-        case 'TSTypeReference': {
-            result.key = ast.typeName.name;
-            result.type = ast.typeName.name;
-            break;
-        }
-        case 'TSUnionType': {
-            result.type = print(ast);
-            result.members = ast.types.map((type) => printType(type));
-            break;
-        }
-    }
-    return result;
-};

package/transformer/utils/visitor.d.ts

@@ -1,2 +0,0 @@
-import { Node } from '@babel/types';
-export declare const visitor: (ast: Node, options: any) => void;

package/transformer/utils/visitor.js

@@ -1,5 +0,0 @@
-import traverse from '@babel/traverse';
-// TODO: options type
-export const visitor = (ast, options) => {
-    (traverse.default || traverse)(ast, options);
-};

package/types/index.d.ts

@@ -1,2 +0,0 @@
-export interface HTMLPlusElement {
-}

package/types/index.js

@@ -1 +0,0 @@
-export {};