@htmlplus/element 0.4.5 → 0.4.8

package/compiler/plugins/document.js

@@ -13,9 +13,10 @@ export const document = (options) => {
             components: []
         };
         for (const context of global.contexts) {
+            const deprecated = hasTag(context.class, 'deprecated');
             const events = context.classEvents.map((event) => {
                 var _a, _b, _c;
-                const isCancelable = (() => {
+                const cancelable = (() => {
                     if (!event.decorators)
                         return false;
                     try {
@@ -36,27 +37,28 @@ export const document = (options) => {
                     catch (_a) { }
                     return false;
                 })();
+                const deprecated = hasTag(event, 'deprecated');
                 const description = (_a = getTags(event).find((tag) => !tag.key)) === null || _a === void 0 ? void 0 : _a.value;
                 const detail = print((_b = event.typeAnnotation) === null || _b === void 0 ? void 0 : _b['typeAnnotation']);
                 const detailReference = getTypeReference(context.fileAST, (_c = event.typeAnnotation) === null || _c === void 0 ? void 0 : _c['typeAnnotation'].typeParameters.params[0]);
-                const isExperimental = hasTag(event, 'experimental');
-                const isModel = hasTag(event, 'model');
+                const experimental = hasTag(event, 'experimental');
+                const model = hasTag(event, 'model');
                 const name = event.key['name'];
                 const tags = getTags(event);
                 return {
+                    cancelable,
+                    deprecated,
                     description,
                     detail,
                     detailReference,
-                    isCancelable,
-                    isExperimental,
-                    isModel,
+                    experimental,
+                    model,
                     name,
                     tags
                 };
             });
+            const experimental = hasTag(context.class, 'experimental');
             const group = (_a = getTag(context.class, 'group')) === null || _a === void 0 ? void 0 : _a.value;
-            const isDeprecated = hasTag(context.class, 'deprecated');
-            const isExperimental = hasTag(context.class, 'experimental');
             const lastModified = glob
                 .sync(path.join(context.directoryPath, '**/*.*'))
                 .map((file) => fs.statSync(file).mtime)
@@ -64,14 +66,11 @@ export const document = (options) => {
                 .pop();
             const methods = context.classMethods.map((method) => {
                 var _a, _b, _c;
+                const async = method.async;
                 const description = (_a = getTags(method).find((tag) => !tag.key)) === null || _a === void 0 ? void 0 : _a.value;
-                const isAsync = method.async;
-                const isDeprecated = hasTag(method, 'deprecated');
-                const isExperimental = hasTag(method, 'experimental');
+                const deprecated = hasTag(method, 'deprecated');
+                const experimental = hasTag(method, 'experimental');
                 const name = method.key['name'];
-                const returns = print((_b = method.returnType) === null || _b === void 0 ? void 0 : _b['typeAnnotation']) || 'void';
-                const returnsReference = getTypeReference(context.fileAST, (_c = method.returnType) === null || _c === void 0 ? void 0 : _c['typeAnnotation']);
-                const tags = getTags(method);
                 // TODO
                 const parameters = method.params.map((param) => {
                     var _a, _b, _c;
@@ -79,12 +78,15 @@ export const document = (options) => {
                         description: (_a = getTags(method, 'param')
                             .map((tag) => parseTag(tag, ' '))
                             .find((tag) => tag.name == param['name'])) === null || _a === void 0 ? void 0 : _a.description,
-                        isOptional: !!param['optional'],
+                        required: !param['optional'],
                         name: param['name'],
                         type: print((_b = param === null || param === void 0 ? void 0 : param['typeAnnotation']) === null || _b === void 0 ? void 0 : _b.typeAnnotation) || undefined,
                         typeReference: getTypeReference(context.fileAST, (_c = param === null || param === void 0 ? void 0 : param['typeAnnotation']) === null || _c === void 0 ? void 0 : _c.typeAnnotation)
                     });
                 });
+                const returns = print((_b = method.returnType) === null || _b === void 0 ? void 0 : _b['typeAnnotation']) || 'void';
+                const returnsReference = getTypeReference(context.fileAST, (_c = method.returnType) === null || _c === void 0 ? void 0 : _c['typeAnnotation']);
+                const tags = getTags(method);
                 const signature = [
                     method.key['name'],
                     '(',
@@ -93,7 +95,7 @@ export const document = (options) => {
                         var _a;
                         let string = '';
                         string += parameter.name;
-                        string += parameter.isOptional ? '?' : '';
+                        string += parameter.required ? '' : '?';
                         string += parameter.type ? ': ' : '';
                         string += (_a = parameter.type) !== null && _a !== void 0 ? _a : '';
                         return string;
@@ -104,15 +106,15 @@ export const document = (options) => {
                     returns
                 ].join('');
                 return {
+                    async,
                     description,
-                    isAsync,
-                    isDeprecated,
-                    isExperimental,
+                    deprecated,
+                    experimental,
                     name,
+                    parameters,
                     returns,
                     returnsReference,
                     tags,
-                    parameters,
                     signature
                 };
             });
@@ -120,9 +122,15 @@ export const document = (options) => {
             const properties = context.classProperties.map((property) => {
                 var _a, _b, _c;
                 const attribute = paramCase(property.key['name']);
+                const deprecated = hasTag(property, 'deprecated');
                 const description = (_a = getTags(property).find((tag) => !tag.key)) === null || _a === void 0 ? void 0 : _a.value;
+                const experimental = hasTag(property, 'experimental');
+                // TODO
+                const initializer = getInitializer(property.value);
+                const model = hasTag(property, 'model');
+                const name = property.key['name'];
                 // TODO
-                const hasReflect = (() => {
+                const reflects = (() => {
                     if (!property.decorators)
                         return false;
                     try {
@@ -143,26 +151,20 @@ export const document = (options) => {
                     catch (_a) { }
                     return false;
                 })();
-                // TODO
-                const initializer = getInitializer(property.value);
-                const isDeprecated = hasTag(property, 'deprecated');
-                const isExperimental = hasTag(property, 'experimental');
-                const isModel = hasTag(property, 'model');
-                const isRequired = !property.optional;
-                const name = property.key['name'];
+                const required = !property.optional;
                 const tags = getTags(property);
                 const type = print((_b = property.typeAnnotation) === null || _b === void 0 ? void 0 : _b['typeAnnotation']);
                 const typeReference = getTypeReference(context.fileAST, (_c = property.typeAnnotation) === null || _c === void 0 ? void 0 : _c['typeAnnotation']);
                 return {
                     attribute,
+                    deprecated,
                     description,
-                    hasReflect,
+                    experimental,
                     initializer,
-                    isDeprecated,
-                    isExperimental,
-                    isModel,
-                    isRequired,
+                    model,
                     name,
+                    reflects,
+                    required,
                     tags,
                     type,
                     typeReference
@@ -222,8 +224,8 @@ export const document = (options) => {
                 // source
                 events,
                 group,
-                isDeprecated,
-                isExperimental,
+                deprecated,
+                experimental,
                 key: context.componentKey,
                 lastModified,
                 methods,

package/compiler/plugins/extract.d.ts

@@ -1,4 +1,4 @@
-import { Context } from '../../types/index.js';
+import { Context } from '../../types';
 export interface ExtractOptions {
     prefix?: string;
 }

package/compiler/plugins/index.d.ts

@@ -1,4 +1,5 @@
 export * from './assets.js';
+export * from './copy.js';
 export * from './customElementReact/index.js';
 export * from './customElement.js';
 export * from './document.js';

package/compiler/plugins/index.js

@@ -1,4 +1,5 @@
 export * from './assets.js';
+export * from './copy.js';
 export * from './customElementReact/index.js';
 export * from './customElement.js';
 export * from './document.js';

package/compiler/plugins/parse.d.ts

@@ -1,4 +1,4 @@
-import { Context } from '../../types/index.js';
+import { Context } from '../../types';
 export declare const parse: () => {
     name: string;
     next: (context: Context) => void;

package/compiler/plugins/read.d.ts

@@ -1,4 +1,4 @@
-import { Context } from '../../types/index.js';
+import { Context } from '../../types';
 export declare const read: () => {
     name: string;
     next: (context: Context) => void;

package/compiler/plugins/style.d.ts

@@ -1,6 +1,6 @@
-import { Context } from '../../types/index.js';
+import { Context } from '../../types';
 export declare type StyleOptions = {
-    references?: (context: Context) => string[];
+    references?: (context: Context) => string | string[];
 };
 export declare const style: (options: StyleOptions) => {
     name: string;

package/compiler/plugins/style.js

@@ -18,16 +18,20 @@ export const style = (options) => {
     const name = 'style';
     options = Object.assign({}, defaults, options);
     const next = (context) => {
-        const references = options.references(context);
+        const references = [options.references(context)].flat();
         for (const reference of references) {
             if (!fs.existsSync(reference))
                 continue;
             context.stylePath = reference;
+            break;
         }
         if (!context.stylePath)
             return;
-        const local = addDependency(context.fileAST, context.stylePath, 'AUTO_IMPORT_STYLE', undefined, true);
+        const { local, node } = addDependency(context.fileAST, context.stylePath, CONSTANTS.AUTO_IMPORT_STYLE);
+        t.addComment(node, 'leading', CONSTANTS.COMMENT_AUTO_ADDED_DEPENDENCY, true);
+        // TODO: remove 'local!'
         const property = t.classProperty(t.identifier(CONSTANTS.STATIC_STYLES), t.identifier(local), undefined, null, undefined, true);
+        t.addComment(property, 'leading', CONSTANTS.COMMENT_AUTO_ADDED_PROPERTY, true);
         context.class.body.body.unshift(property);
     };
     return { name, next };

package/compiler/plugins/validate.d.ts

@@ -1,4 +1,4 @@
-import { Context } from '../../types/index.js';
+import { Context } from '../../types';
 export declare const validate: () => {
     name: string;
     next: (context: Context) => void;

package/compiler/plugins/visualStudioCode.d.ts

@@ -1,4 +1,4 @@
-import { Global } from '../../types/index.js';
+import { Global } from '../../types';
 export interface VisualStudioCodeOptions {
     destination: string;
 }

package/compiler/plugins/webTypes.d.ts

@@ -1,9 +1,9 @@
-import { Global } from '../../types/index.js';
+import { Global } from '../../types';
 export interface WebTypesOptions {
     destination: string;
     packageName: string;
     packageVersion: string;
-    docUrl: () => string;
+    reference?: (componentTag: string) => string;
 }
 export declare const webTypes: (options: WebTypesOptions) => {
     name: string;

package/compiler/plugins/webTypes.js

@@ -1,12 +1,13 @@
-import { camelCase, paramCase } from 'change-case';
+import { paramCase } from 'change-case';
 import fs from 'fs-extra';
 import path from 'path';
-import { getTags, print } from '../utils/index.js';
+import { getInitializer, getTags, hasTag, parseTag, print } from '../utils/index.js';
 const defaults = {};
 export const webTypes = (options) => {
     const name = 'webTypes';
     options = Object.assign({}, defaults, options);
     const finish = (global) => {
+        var _a, _b, _c, _d, _e;
         const json = {
             '$schema': 'http://json.schemastore.org/web-types',
             'name': options.packageName,
@@ -19,58 +20,81 @@ export const webTypes = (options) => {
             },
             'contributions': {
                 html: {
-                    elements: global.contexts
-                        .sort((a, b) => ((a.componentTag || '') > (b.componentTag || '') ? 1 : -1))
-                        .map((context) => {
-                        var _a, _b;
-                        return ({
-                            'name': context.componentTag,
-                            'description': '',
-                            'doc-url': options.docUrl(),
-                            'js': {
-                                properties: [
-                                    ...(context.classProperties || []).map((property) => {
-                                        var _a, _b;
-                                        return ({
-                                            name: camelCase(property.key['name']),
-                                            description: (_a = getTags(property).find((tag) => !tag.key)) === null || _a === void 0 ? void 0 : _a.value,
-                                            value: {
-                                                type: print((_b = property.typeAnnotation) === null || _b === void 0 ? void 0 : _b['typeAnnotation'])
-                                            }
-                                        });
-                                    }),
-                                    ...(context.classMethods || []).map((method) => {
-                                        var _a;
-                                        return ({
-                                            name: camelCase(method.key['name']),
-                                            description: (_a = getTags(method).find((tag) => !tag.key)) === null || _a === void 0 ? void 0 : _a.value,
-                                            value: {}
-                                        });
-                                    })
-                                ],
-                                events: (_a = context.classEvents) === null || _a === void 0 ? void 0 : _a.map((event) => {
-                                    var _a;
-                                    return ({
-                                        name: paramCase(event.key['name']),
-                                        description: (_a = getTags(event).find((tag) => !tag.key)) === null || _a === void 0 ? void 0 : _a.value
-                                    });
-                                })
-                            },
-                            'attributes': (_b = context.classProperties) === null || _b === void 0 ? void 0 : _b.map((property) => {
-                                var _a, _b;
-                                return ({
-                                    name: paramCase(property.key['name']),
-                                    description: (_a = getTags(property).find((tag) => !tag.key)) === null || _a === void 0 ? void 0 : _a.value,
-                                    value: {
-                                        type: print((_b = property.typeAnnotation) === null || _b === void 0 ? void 0 : _b['typeAnnotation'])
-                                    }
-                                });
-                            })
-                        });
-                    })
+                    elements: []
                 }
             }
         };
+        const extract = (member) => {
+            var _a;
+            return ({
+                name: member.key['name'],
+                description: (_a = getTags(member).find((tag) => !tag.key)) === null || _a === void 0 ? void 0 : _a.value,
+                deprecated: hasTag(member, 'deprecated'),
+                experimental: hasTag(member, 'experimental')
+            });
+        };
+        for (const context of global.contexts) {
+            const attributes = (_a = context.classProperties) === null || _a === void 0 ? void 0 : _a.map((property) => {
+                var _a;
+                return Object.assign({}, extract(property), {
+                    name: paramCase(property.key['name']),
+                    value: {
+                        // kind: TODO
+                        /**
+                         * For Example
+                         * 01) type: "''"
+                         * 02) type: "null"
+                         * 03) type: "undefined"
+                         * 04) type: "boolean"
+                         * 05) type: "string"
+                         * 06) type: "number"
+                         * 07) type: "boolean | string | number"
+                         * 08) type: "string[]"
+                         * 09) type: "1 | 2 | 3"
+                         * 10) type: "'Value-1' | 'Value-2'"
+                         */
+                        type: print((_a = property.typeAnnotation) === null || _a === void 0 ? void 0 : _a['typeAnnotation'])
+                        // required: TODO
+                        // default: TODO
+                    },
+                    default: getInitializer(property.value)
+                });
+            });
+            const events = (_b = context.classEvents) === null || _b === void 0 ? void 0 : _b.map((event) => Object.assign({}, extract(event), {
+                name: paramCase(event.key['name']) // TODO
+                // 'value': TODO
+            }));
+            const methods = (_c = context.classMethods) === null || _c === void 0 ? void 0 : _c.map((method) => Object.assign({}, extract(method), {
+            // 'value': TODO
+            }));
+            const properties = (_d = context.classProperties) === null || _d === void 0 ? void 0 : _d.map((property) => Object.assign({}, extract(property), {
+                // 'value': TODO
+                default: getInitializer(property.value)
+            }));
+            const slots = getTags(context.class, 'slot').map((tag) => {
+                const { description, name } = parseTag(tag);
+                return {
+                    'name': name,
+                    'description': description,
+                    'doc-url': undefined,
+                    'deprecated': false,
+                    'experimental': false
+                };
+            });
+            json.contributions.html.elements.push({
+                'name': context.componentTag,
+                'description': 'TODO',
+                'doc-url': (_e = options.reference) === null || _e === void 0 ? void 0 : _e.call(options, context.componentTag),
+                'deprecated': hasTag(context.class, 'deprecated'),
+                'experimental': hasTag(context.class, 'experimental'),
+                'js': {
+                    events,
+                    properties: [].concat(properties, methods)
+                },
+                attributes,
+                slots
+            });
+        }
         const dirname = path.dirname(options.destination);
         fs.ensureDirSync(dirname);
         fs.writeJSONSync(options.destination, json, { encoding: 'utf8', spaces: 2 });

package/compiler/utils/addDependency.d.ts

@@ -1,2 +1,9 @@
-import { File } from '@babel/types';
-export declare const addDependency: (file: File, source: string, imported: string, local?: string, isDefault?: boolean) => string;
+import { File, ImportDeclaration } from '@babel/types';
+interface AddDependencyReturns {
+    local?: string;
+    node: ImportDeclaration;
+}
+export declare function addDependency(path: File | any, source: string): AddDependencyReturns;
+export declare function addDependency(path: File | any, source: string, local: string): AddDependencyReturns;
+export declare function addDependency(path: File | any, source: string, local: string, imported: string): AddDependencyReturns;
+export {};

package/compiler/utils/addDependency.js

@@ -1,41 +1,60 @@
 import t from '@babel/types';
 import { visitor } from './visitor.js';
-export const addDependency = (file, source, imported, local, isDefault) => {
-    let node;
+export function addDependency(path, source, local, imported) {
+    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;
-            node = path.node;
+            declaration = path.node;
         }
     });
-    let specifier = node === null || node === void 0 ? void 0 : node.specifiers.find((specifier) => {
+    if (isNormal && declaration)
+        return {
+            node: declaration
+        };
+    let specifier = declaration === null || declaration === void 0 ? void 0 : declaration.specifiers.find((specifier) => {
         var _a;
         if (isDefault) {
             return specifier.type == 'ImportDefaultSpecifier';
         }
-        else {
+        else if (isImport) {
             return ((_a = specifier.imported) === null || _a === void 0 ? void 0 : _a.name) == imported;
         }
     });
     if (specifier)
-        return specifier.local.name;
+        return {
+            local: specifier.local.name,
+            node: declaration
+        };
     if (isDefault) {
-        specifier = t.importDefaultSpecifier(t.identifier(imported));
+        specifier = t.importDefaultSpecifier(t.identifier(local));
     }
-    else {
-        specifier = t.importSpecifier(t.identifier(local !== null && local !== void 0 ? local : imported), t.identifier(imported));
+    else if (isImport) {
+        specifier = t.importSpecifier(t.identifier(local), t.identifier(imported));
     }
-    if (node) {
+    if (declaration) {
         if (isDefault) {
-            node.specifiers.unshift(specifier);
+            declaration.specifiers.unshift(specifier);
         }
-        else {
-            node.specifiers.push(specifier);
+        else if (isImport) {
+            declaration.specifiers.push(specifier);
         }
     }
     else {
-        file.program.body.unshift(t.importDeclaration([specifier], t.stringLiteral(source)));
+        declaration = t.importDeclaration(specifier ? [specifier] : [], t.stringLiteral(source));
+        // TODO
+        (file.program || file).body.unshift(declaration);
     }
-    return isDefault ? imported : local !== null && local !== void 0 ? local : imported;
-};
+    return {
+        local,
+        node: declaration
+    };
+}

package/compiler/utils/getInitializer.d.ts

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

package/compiler/utils/getInitializer.js

@@ -1,10 +1,4 @@
-// TODO: return type
 export const getInitializer = (node) => {
-    if (!node)
-        return node;
-    const value = node;
-    if (!value)
-        return;
-    const extra = value.extra || {};
-    return extra.raw || value['value'];
+    var _a;
+    return ((_a = node === null || node === void 0 ? void 0 : node.extra) === null || _a === void 0 ? void 0 : _a.raw) || (node === null || node === void 0 ? void 0 : node['value']);
 };

package/compiler/utils/index.d.ts

@@ -7,6 +7,7 @@ export * from './hasDecorator.js';
 export * from './isDirectoryEmpty.js';
 export * from './printType.js';
 export * from './print.js';
+export * from './removeUnusedImport.js';
 export * from './renderTemplate.js';
 export * from './tags.js';
 export * from './visitor.js';

package/compiler/utils/index.js

@@ -7,6 +7,7 @@ export * from './hasDecorator.js';
 export * from './isDirectoryEmpty.js';
 export * from './printType.js';
 export * from './print.js';
+export * from './removeUnusedImport.js';
 export * from './renderTemplate.js';
 export * from './tags.js';
 export * from './visitor.js';

package/compiler/utils/removeUnusedImport.d.ts

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

package/compiler/utils/removeUnusedImport.js

@@ -0,0 +1,49 @@
+import t from '@babel/types';
+import { visitor } from './visitor.js';
+// TODO
+export const removeUnusedImport = (ast) => {
+    visitor(ast, {
+        Program: {
+            exit(path) {
+                for (const entry of Object.entries(path.scope.bindings)) {
+                    let { kind, path, referenced, referencePaths } = entry[1];
+                    if (kind !== 'module')
+                        continue;
+                    if (referenced) {
+                        referenced = false;
+                        for (const referencePath of referencePaths) {
+                            let find = true;
+                            let parent = referencePath;
+                            while (parent) {
+                                if (!parent.node) {
+                                    find = false;
+                                    break;
+                                }
+                                parent = parent.parentPath;
+                            }
+                            if (!find)
+                                continue;
+                            referenced = true;
+                            break;
+                        }
+                    }
+                    if (referenced)
+                        continue;
+                    const source = path.parentPath.get('source');
+                    if (!t.isStringLiteral(source))
+                        continue;
+                    if (path.isImportSpecifier()) {
+                        path.remove();
+                        if (path.parentPath.node.specifiers.length)
+                            continue;
+                        path.parentPath.remove();
+                        continue;
+                    }
+                    if (!path.parentPath)
+                        continue;
+                    path.parentPath.remove();
+                }
+            }
+        }
+    });
+};

package/constants/index.d.ts

@@ -1,6 +1,7 @@
 export declare const PACKAGE_NAME = "@htmlplus/element";
-export declare const API_HOST = "$host$";
-export declare const API_STATUS = "$status$";
+export declare const API_HOST: unique symbol;
+export declare const API_INSTANCE: unique symbol;
+export declare const API_STATUS: unique symbol;
 export declare const DECORATOR_ELEMENT = "Element";
 export declare const DECORATOR_EVENT = "Event";
 export declare const DECORATOR_PROPERTY = "Property";
@@ -14,6 +15,8 @@ export declare const LIFECYCLE_UPDATE = "updateCallback";
 export declare const LIFECYCLE_UPDATED = "updatedCallback";
 export declare const METHOD_RENDER = "render";
 export declare const STATIC_MEMBERS = "members";
+export declare const STATIC_MEMBERS_INITIALIZER = "default";
+export declare const STATIC_MEMBERS_TYPE = "type";
 export declare const STATIC_STYLES = "styles";
 export declare const TYPE_BOOLEAN = "boolean";
 export declare const TYPE_DATE = "date";
@@ -21,3 +24,7 @@ export declare const TYPE_FUNCTION = "function";
 export declare const TYPE_STRING = "string";
 export declare const TYPE_NUMBER = "number";
 export declare const UTILS_STYLE_MAP = "styles";
+export declare const VENDOR_UHTML = "@htmlplus/element/client/vendors/uhtml.js";
+export declare const AUTO_IMPORT_STYLE = "AUTO_IMPORT_STYLE";
+export declare const COMMENT_AUTO_ADDED_DEPENDENCY = " THIS DEPENDENCY IS AUTO-ADDED, DO NOT EDIT MANUALY";
+export declare const COMMENT_AUTO_ADDED_PROPERTY = " THIS PROPERTY IS AUTO-ADDED, DO NOT EDIT MANUALY";

package/constants/index.js

@@ -1,8 +1,9 @@
 export const PACKAGE_NAME = '@htmlplus/element';
 // apis
-export const API_HOST = '$host$';
+export const API_HOST = Symbol();
+export const API_INSTANCE = Symbol();
 // TODO
-export const API_STATUS = '$status$';
+export const API_STATUS = Symbol();
 // decorators
 export const DECORATOR_ELEMENT = 'Element';
 export const DECORATOR_EVENT = 'Event';
@@ -20,6 +21,8 @@ export const LIFECYCLE_UPDATED = 'updatedCallback';
 export const METHOD_RENDER = 'render';
 // statics
 export const STATIC_MEMBERS = 'members';
+export const STATIC_MEMBERS_INITIALIZER = 'default';
+export const STATIC_MEMBERS_TYPE = 'type';
 export const STATIC_STYLES = 'styles';
 // types
 export const TYPE_BOOLEAN = 'boolean';
@@ -29,3 +32,8 @@ export const TYPE_STRING = 'string';
 export const TYPE_NUMBER = 'number';
 // utils
 export const UTILS_STYLE_MAP = 'styles';
+// TODO
+export const VENDOR_UHTML = '@htmlplus/element/client/vendors/uhtml.js';
+export const AUTO_IMPORT_STYLE = 'AUTO_IMPORT_STYLE';
+export const COMMENT_AUTO_ADDED_DEPENDENCY = ' THIS DEPENDENCY IS AUTO-ADDED, DO NOT EDIT MANUALY';
+export const COMMENT_AUTO_ADDED_PROPERTY = ' THIS PROPERTY IS AUTO-ADDED, DO NOT EDIT MANUALY';