@mxpicture/gcp-functions-tools 0.1.59

package/dist/meta/meta.common.js

@@ -0,0 +1,87 @@
+import ts from "typescript";
+import { guardMetaFileExtension, guardMetaFileType, MetaFileExtension, MetaFileType, } from "./meta.enum.js";
+import { format } from "prettier";
+import { createHash } from "node:crypto";
+export var TargetType;
+(function (TargetType) {
+    TargetType["common"] = "common";
+    TargetType["frontend"] = "frontend";
+    TargetType["backend"] = "backend";
+})(TargetType || (TargetType = {}));
+export const isTemplateFile = (filename) => isTsFile(filename, MetaFileType.template);
+export const isTsFile = (filename, type) => isAnyFile(filename, type, MetaFileExtension.ts);
+export const isAnyFile = (filename, type, ext) => {
+    try {
+        const parts = extractFileParts(filename);
+        if (type && type !== parts.type)
+            return false;
+        if (ext && ext !== parts.ext)
+            return false;
+    }
+    catch {
+        return false;
+    }
+    return true;
+};
+export const extractFileParts = (filename) => {
+    const parts = filename.split(".");
+    if (parts.length < 3)
+        throw new Error(`Filename "${filename}" invalid (3 parts divided by ".")`);
+    const _type = parts.shift();
+    const _ext = parts.pop();
+    const type = guardMetaFileType(_type);
+    const ext = guardMetaFileExtension(_ext);
+    if (!type)
+        throw new Error(`Filename "${filename}" invalid (type: ${_type})`);
+    if (!ext)
+        throw new Error(`Filename "${filename}" invalid (extension: ${_ext})`);
+    return {
+        filename,
+        type,
+        ext,
+        middlePart: parts.join("."),
+    };
+};
+export const concatFileParts = (parts) => [parts.type, parts.middlePart, parts.generated ? "gen" : null, parts.ext]
+    .filter((p) => !!p)
+    .join(".");
+export const toFilename = (p) => concatFileParts({
+    ...extractFileParts(p.filename),
+    type: p.type,
+    ext: p.ext ?? MetaFileExtension.ts,
+    generated: p.generated,
+});
+export const formatCode = async (...lines) => format(lines.join("\n"), { parser: "typescript" });
+export const formatJson = async (...lines) => format(lines.join("\n"), { parser: "json" });
+// // export const toFilePath = (
+// //   filePath: string,
+// //   type: MetaFileType,
+// //   ext: MetaFileExtension = MetaFileExtension.ts,
+// // ): string | undefined => {
+// //   const name = toFilename(basename(filePath), type, ext);
+// //   const dir = dirname(filePath);
+// //   return name ? `${dir}/${name}` : undefined;
+// // };
+export const lowerFirstLetter = (val) => val.length > 1
+    ? val.charAt(0).toLocaleLowerCase() + val.slice(1)
+    : val.toLocaleLowerCase();
+export const upperFirstLetter = (val) => val.length > 1
+    ? val.charAt(0).toUpperCase() + val.slice(1)
+    : val.toUpperCase();
+export const createSourceFiles = (filePaths) => {
+    const program = ts.createProgram(filePaths, {
+        target: ts.ScriptTarget.ES2023,
+        module: ts.ModuleKind.Node20,
+        strict: true,
+    });
+    const checker = program.getTypeChecker();
+    const results = [];
+    for (const filePath of filePaths) {
+        const sourceFile = program.getSourceFile(filePath);
+        if (!sourceFile)
+            continue;
+        results.push({ sourceFile, filePath, checker });
+    }
+    return results;
+};
+export const calcHash = (input) => createHash("sha256").update(input).digest("hex");

package/dist/meta/meta.decorators.d.ts

@@ -0,0 +1,26 @@
+import { MetaPropertyDecorator } from "./meta.properties.js";
+import type { MetaInterfaceOptions, MetaNumberOptions, MetaStringOptions, MetaArrayOptions, MetaObjectOptions, MetaDateOptions, MetaBooleanOptions, WithoutType, MetaKeyOptions, MetaCreateTimeOptions, MetaUpdateTimeOptions, MetaMainInterfaceOptions } from "./meta.types.js";
+import { MetaMainDecorator } from "./meta.main.js";
+export declare const MetaInterface: (options: WithoutType<MetaInterfaceOptions>, decoratorType?: MetaMainDecorator.MetaInterface) => <T extends {
+    new (...args: any[]): {};
+}>(constructor: T) => T;
+export declare const MetaMainInterface: (options: WithoutType<MetaMainInterfaceOptions>, decoratorType?: MetaMainDecorator.MetaMainInterface) => <T extends {
+    new (...args: any[]): {};
+}>(constructor: T) => T;
+export declare const MetaKey: (options: Omit<WithoutType<MetaKeyOptions>, "optional">, decoratorType?: MetaPropertyDecorator.MetaKey) => (target: any, propertyKey: string) => void;
+export type MetaCreateTimeOptionsBase = WithoutType<MetaCreateTimeOptions>;
+export declare const MetaCreateTime: <Opt extends MetaCreateTimeOptionsBase>(options: Opt, decoratorType?: MetaPropertyDecorator.MetaCreateTime) => <T, K extends Extract<keyof T, string>>(target: T, propertyKey: K & (T[K] extends (Opt["optional"] extends true ? Date | undefined : Date) ? unknown : never)) => void;
+export type MetaUpdateTimeOptionsBase = WithoutType<MetaUpdateTimeOptions>;
+export declare const MetaUpdateTime: <Opt extends MetaUpdateTimeOptionsBase>(options: Opt, decoratorType?: MetaPropertyDecorator.MetaUpdateTime) => <T, K extends Extract<keyof T, string>>(target: T, propertyKey: K & (T[K] extends (Opt["optional"] extends true ? Date | undefined : Date) ? unknown : never)) => void;
+export type MetaNumberOptionsBase = WithoutType<MetaNumberOptions>;
+export declare const MetaNumber: <Opt extends MetaNumberOptionsBase>(options: Opt, decoratorType?: MetaPropertyDecorator.MetaNumber) => <T, K extends Extract<keyof T, string>>(target: T, propertyKey: K & (T[K] extends (Opt["optional"] extends true ? number | undefined : number) ? unknown : never)) => void;
+export type MetaStringOptionsBase = WithoutType<MetaStringOptions>;
+export declare const MetaString: <Opt extends MetaStringOptionsBase>(options: Opt, decoratorType?: MetaPropertyDecorator.MetaString) => <T, K extends Extract<keyof T, string>>(target: T, propertyKey: K & (T[K] extends (Opt["optional"] extends true ? string | undefined : string) ? unknown : never)) => void;
+export type MetaArrayOptionsBase = WithoutType<MetaArrayOptions>;
+export declare const MetaArray: <Opt extends MetaArrayOptionsBase>(options: Opt, decoratorType?: MetaPropertyDecorator.MetaArray) => <T, K extends Extract<keyof T, string>>(target: T, propertyKey: K & (T[K] extends (Opt["optional"] extends true ? unknown[] | undefined : unknown[]) ? unknown : never)) => void;
+export type MetaObjectOptionsBase = WithoutType<MetaObjectOptions>;
+export declare const MetaObject: <Opt extends MetaObjectOptionsBase>(options: Opt, decoratorType?: MetaPropertyDecorator.MetaObject) => <T, K extends Extract<keyof T, string>>(target: T, propertyKey: K & (T[K] extends (Opt["optional"] extends true ? object | undefined : object) ? unknown : never)) => void;
+export type MetaDateOptionsBase = WithoutType<MetaDateOptions>;
+export declare const MetaDate: <Opt extends MetaDateOptionsBase>(options: Opt, decoratorType?: MetaPropertyDecorator.MetaDate) => <T, K extends Extract<keyof T, string>>(target: T, propertyKey: K & (T[K] extends (Opt["optional"] extends true ? Date | undefined : Date) ? unknown : never)) => void;
+export type MetaBooleanOptionsBase = WithoutType<MetaBooleanOptions>;
+export declare const MetaBoolean: <Opt extends MetaBooleanOptionsBase>(options: Opt, decoratorType?: MetaPropertyDecorator.MetaBoolean) => <T, K extends Extract<keyof T, string>>(target: T, propertyKey: K & (T[K] extends (Opt["optional"] extends true ? boolean | undefined : boolean) ? unknown : never)) => void;

package/dist/meta/meta.decorators.js

@@ -0,0 +1,21 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { MetaPropertyDecorator } from "./meta.properties.js";
+import { MetaMainDecorator } from "./meta.main.js";
+// after adding new decorator add it to MetaPropDecorator too
+export const MetaInterface = (options, decoratorType = MetaMainDecorator.MetaInterface) => (constructor) => {
+    return constructor;
+};
+export const MetaMainInterface = (options, decoratorType = MetaMainDecorator.MetaMainInterface) => (constructor) => {
+    return constructor;
+};
+export const MetaKey = (options, decoratorType = MetaPropertyDecorator.MetaKey) => (target, propertyKey) => { };
+export const MetaCreateTime = (options, decoratorType = MetaPropertyDecorator.MetaCreateTime) => (target, propertyKey) => { };
+export const MetaUpdateTime = (options, decoratorType = MetaPropertyDecorator.MetaUpdateTime) => (target, propertyKey) => { };
+export const MetaNumber = (options, decoratorType = MetaPropertyDecorator.MetaNumber) => (target, propertyKey) => { };
+export const MetaString = (options, decoratorType = MetaPropertyDecorator.MetaString) => (target, propertyKey) => { };
+export const MetaArray = (options, decoratorType = MetaPropertyDecorator.MetaArray) => (target, propertyKey) => { };
+export const MetaObject = (options, decoratorType = MetaPropertyDecorator.MetaObject) => (target, propertyKey) => { };
+export const MetaDate = (options, decoratorType = MetaPropertyDecorator.MetaDate) => (target, propertyKey) => { };
+export const MetaBoolean = (options, decoratorType = MetaPropertyDecorator.MetaBoolean) => (target, propertyKey) => { };

package/dist/meta/meta.enum.d.ts

@@ -0,0 +1,87 @@
+export declare enum MetaFileType {
+    doc = "doc",
+    template = "template",
+    routes = "routes",
+    backend = "backend",
+    frontend = "frontend",
+    zod = "zod",
+    annotations = "annotations"
+}
+export declare const guardMetaFileType: (type: string | undefined) => MetaFileType | undefined;
+export declare enum MetaFileExtension {
+    ts = "ts",
+    json = "json"
+}
+export declare const guardMetaFileExtension: (ext: string | undefined) => MetaFileExtension | undefined;
+export declare enum MetaPropertyType {
+    string = "string",
+    number = "number",
+    boolean = "boolean",
+    date = "date",
+    array = "array",
+    object = "object",
+    key = "key",
+    createTime = "createTime",
+    updateTime = "updateTime"
+}
+export declare enum MetaMainType {
+    interface = "interface",
+    mainInterface = "mainInterface"
+}
+export declare enum MetaPropertyArrayType {
+    string = "string",
+    number = "number",
+    boolean = "boolean",
+    date = "date",
+    object = "object"
+}
+export declare enum MetaNumberFormat {
+    int32 = "int32",
+    uint32 = "uint32",
+    float32 = "float32",
+    float64 = "float64",
+    safeint = "safeint"
+}
+export declare enum MetaStringFormat {
+    email = "email",
+    url = "url",
+    emoji = "emoji",
+    uuid = "uuid",
+    guid = "guid",
+    nanoid = "nanoid",
+    cuid = "cuid",
+    cuid2 = "cuid2",
+    ulid = "ulid",
+    xid = "xid",
+    ksuid = "ksuid",
+    datetime = "datetime",
+    date = "date",
+    time = "time",
+    duration = "duration",
+    ipv4 = "ipv4",
+    ipv6 = "ipv6",
+    cidrv4 = "cidrv4",
+    cidrv6 = "cidrv6",
+    base64 = "base64",
+    base64url = "base64url",
+    json_string = "json_string",
+    e164 = "e164",
+    lowercase = "lowercase",
+    uppercase = "uppercase",
+    regex = "regex",
+    jwt = "jwt",
+    starts_with = "starts_with",
+    ends_with = "ends_with",
+    includes = "includes"
+}
+export declare enum CrudRouteName {
+    create = "create",
+    update = "update",
+    delete = "delete",
+    get = "get",
+    query = "query",
+    count = "count",
+    exists = "exists"
+}
+export declare const isCrudRoute: (routeName: string) => boolean;
+export declare const hasCrudRoute: (routeNames: string[]) => boolean;

package/dist/meta/meta.enum.js

@@ -0,0 +1,99 @@
+export var MetaFileType;
+(function (MetaFileType) {
+    MetaFileType["doc"] = "doc";
+    MetaFileType["template"] = "template";
+    MetaFileType["routes"] = "routes";
+    MetaFileType["backend"] = "backend";
+    MetaFileType["frontend"] = "frontend";
+    MetaFileType["zod"] = "zod";
+    MetaFileType["annotations"] = "annotations";
+})(MetaFileType || (MetaFileType = {}));
+export const guardMetaFileType = (type) => type && Object.values(MetaFileType).filter((t) => t === type)
+    ? type
+    : undefined;
+export var MetaFileExtension;
+(function (MetaFileExtension) {
+    MetaFileExtension["ts"] = "ts";
+    MetaFileExtension["json"] = "json";
+})(MetaFileExtension || (MetaFileExtension = {}));
+export const guardMetaFileExtension = (ext) => ext && Object.values(MetaFileExtension).filter((e) => e === ext)
+    ? ext
+    : undefined;
+export var MetaPropertyType;
+(function (MetaPropertyType) {
+    MetaPropertyType["string"] = "string";
+    MetaPropertyType["number"] = "number";
+    MetaPropertyType["boolean"] = "boolean";
+    MetaPropertyType["date"] = "date";
+    MetaPropertyType["array"] = "array";
+    MetaPropertyType["object"] = "object";
+    MetaPropertyType["key"] = "key";
+    MetaPropertyType["createTime"] = "createTime";
+    MetaPropertyType["updateTime"] = "updateTime";
+})(MetaPropertyType || (MetaPropertyType = {}));
+export var MetaMainType;
+(function (MetaMainType) {
+    MetaMainType["interface"] = "interface";
+    MetaMainType["mainInterface"] = "mainInterface";
+})(MetaMainType || (MetaMainType = {}));
+export var MetaPropertyArrayType;
+(function (MetaPropertyArrayType) {
+    MetaPropertyArrayType["string"] = "string";
+    MetaPropertyArrayType["number"] = "number";
+    MetaPropertyArrayType["boolean"] = "boolean";
+    MetaPropertyArrayType["date"] = "date";
+    MetaPropertyArrayType["object"] = "object";
+})(MetaPropertyArrayType || (MetaPropertyArrayType = {}));
+export var MetaNumberFormat;
+(function (MetaNumberFormat) {
+    MetaNumberFormat["int32"] = "int32";
+    MetaNumberFormat["uint32"] = "uint32";
+    MetaNumberFormat["float32"] = "float32";
+    MetaNumberFormat["float64"] = "float64";
+    MetaNumberFormat["safeint"] = "safeint";
+})(MetaNumberFormat || (MetaNumberFormat = {}));
+export var MetaStringFormat;
+(function (MetaStringFormat) {
+    MetaStringFormat["email"] = "email";
+    MetaStringFormat["url"] = "url";
+    MetaStringFormat["emoji"] = "emoji";
+    MetaStringFormat["uuid"] = "uuid";
+    MetaStringFormat["guid"] = "guid";
+    MetaStringFormat["nanoid"] = "nanoid";
+    MetaStringFormat["cuid"] = "cuid";
+    MetaStringFormat["cuid2"] = "cuid2";
+    MetaStringFormat["ulid"] = "ulid";
+    MetaStringFormat["xid"] = "xid";
+    MetaStringFormat["ksuid"] = "ksuid";
+    MetaStringFormat["datetime"] = "datetime";
+    MetaStringFormat["date"] = "date";
+    MetaStringFormat["time"] = "time";
+    MetaStringFormat["duration"] = "duration";
+    MetaStringFormat["ipv4"] = "ipv4";
+    MetaStringFormat["ipv6"] = "ipv6";
+    MetaStringFormat["cidrv4"] = "cidrv4";
+    MetaStringFormat["cidrv6"] = "cidrv6";
+    MetaStringFormat["base64"] = "base64";
+    MetaStringFormat["base64url"] = "base64url";
+    MetaStringFormat["json_string"] = "json_string";
+    MetaStringFormat["e164"] = "e164";
+    MetaStringFormat["lowercase"] = "lowercase";
+    MetaStringFormat["uppercase"] = "uppercase";
+    MetaStringFormat["regex"] = "regex";
+    MetaStringFormat["jwt"] = "jwt";
+    MetaStringFormat["starts_with"] = "starts_with";
+    MetaStringFormat["ends_with"] = "ends_with";
+    MetaStringFormat["includes"] = "includes";
+})(MetaStringFormat || (MetaStringFormat = {}));
+export var CrudRouteName;
+(function (CrudRouteName) {
+    CrudRouteName["create"] = "create";
+    CrudRouteName["update"] = "update";
+    CrudRouteName["delete"] = "delete";
+    CrudRouteName["get"] = "get";
+    CrudRouteName["query"] = "query";
+    CrudRouteName["count"] = "count";
+    CrudRouteName["exists"] = "exists";
+})(CrudRouteName || (CrudRouteName = {}));
+export const isCrudRoute = (routeName) => !!Object.values(CrudRouteName).find((r) => r === routeName);
+export const hasCrudRoute = (routeNames) => !!routeNames.find((routeName) => isCrudRoute(routeName));

package/dist/meta/meta.imports.d.ts

@@ -0,0 +1,11 @@
+import ts from "typescript";
+import { MetaImport } from "./meta.types.js";
+export interface ExtractedImport {
+    module: string;
+    defaultImport?: string;
+    namedImports?: string[];
+    namespaceImport?: string;
+    isTypeOnly?: boolean;
+}
+export declare const extractNamedImports: (sourceFile: ts.SourceFile | string) => MetaImport[];
+export declare const extractImports: (sourceFile: ts.SourceFile) => ExtractedImport[];

package/dist/meta/meta.imports.js

@@ -0,0 +1,54 @@
+import ts from "typescript";
+import { createSourceFiles } from "./meta.common.js";
+export const extractNamedImports = (sourceFile) => {
+    if (typeof sourceFile === "string") {
+        const files = createSourceFiles([sourceFile]);
+        if (files.length === 0)
+            return [];
+        sourceFile = files[0].sourceFile;
+    }
+    const results = [];
+    const imports = extractImports(sourceFile);
+    for (const imp of imports) {
+        if (!imp.namedImports || imp.namedImports.length === 0)
+            continue;
+        results.push({
+            path: imp.module,
+            props: [...imp.namedImports],
+            isType: imp.isTypeOnly,
+        });
+    }
+    return results;
+};
+export const extractImports = (sourceFile) => {
+    const imports = [];
+    sourceFile.forEachChild((node) => {
+        if (ts.isImportDeclaration(node) && node.moduleSpecifier) {
+            const moduleName = node.moduleSpecifier.text;
+            let defaultImport;
+            let namedImports = [];
+            let namespaceImport;
+            if (!node.importClause)
+                return;
+            if (node.importClause.name)
+                defaultImport = node.importClause.name.text;
+            const isTypeOnly = node.importClause.phaseModifier === ts.SyntaxKind.TypeKeyword;
+            if (node.importClause.namedBindings) {
+                if (ts.isNamedImports(node.importClause.namedBindings)) {
+                    namedImports = node.importClause.namedBindings.elements.map((el) => el.name.text);
+                }
+                else if (ts.isNamespaceImport(node.importClause.namedBindings)) {
+                    namespaceImport = node.importClause.namedBindings.name.text;
+                }
+            }
+            imports.push({
+                module: moduleName,
+                defaultImport,
+                namedImports: namedImports.length ? namedImports : undefined,
+                namespaceImport,
+                isTypeOnly,
+            });
+        }
+    });
+    return imports;
+};

package/dist/meta/meta.main.d.ts

@@ -0,0 +1,32 @@
+import { MetaMainType } from "./meta.enum.js";
+import { MetaPropertyData } from "./meta.properties.js";
+import { MetaImport, MetaInterfaceOptions, MetaMainBaseOptions, MetaMainInterfaceOptions, MetaRouteParams, WithoutBase } from "./meta.types.js";
+export type MetaMainDecoratorMap<DEF = any> = Record<MetaMainDecorator, DEF>;
+export type WithMainDecoratorMap<T, R extends MetaMainDecoratorMap<T>> = R;
+export declare enum MetaMainDecorator {
+    MetaInterface = "MetaInterface",
+    MetaMainInterface = "MetaMainInterface"
+}
+export declare const metaMainOptionsMap: MetaMainOptionsMap;
+export type MetaMainOptionsMap = WithMainDecoratorMap<MetaMainType, {
+    [MetaMainDecorator.MetaInterface]: MetaMainType.interface;
+    [MetaMainDecorator.MetaMainInterface]: MetaMainType.mainInterface;
+}>;
+export type MetaMainOptionsBase = WithMainDecoratorMap<MetaMainBaseOptions, {
+    [MetaMainDecorator.MetaInterface]: MetaInterfaceOptions;
+    [MetaMainDecorator.MetaMainInterface]: MetaMainInterfaceOptions;
+}>;
+export type MetaMainOptions = Partial<WithMainDecoratorMap<WithoutBase<MetaMainBaseOptions>, {
+    [MetaMainDecorator.MetaInterface]: WithoutBase<MetaMainOptionsBase[MetaMainDecorator.MetaInterface]>;
+    [MetaMainDecorator.MetaMainInterface]: WithoutBase<MetaMainOptionsBase[MetaMainDecorator.MetaMainInterface]>;
+}>>;
+export type MetaRoutes = Record<string, MetaRouteParams>;
+export interface MetaMainData {
+    templateName: string;
+    title: string;
+    inputFilePath: string;
+    repoInputFilePath: string;
+    properties: MetaPropertyData[];
+    routes: MetaRoutes;
+    additionalImports?: MetaImport[];
+}

package/dist/meta/meta.main.js

@@ -0,0 +1,10 @@
+import { MetaMainType } from "./meta.enum.js";
+export var MetaMainDecorator;
+(function (MetaMainDecorator) {
+    MetaMainDecorator["MetaInterface"] = "MetaInterface";
+    MetaMainDecorator["MetaMainInterface"] = "MetaMainInterface";
+})(MetaMainDecorator || (MetaMainDecorator = {}));
+export const metaMainOptionsMap = {
+    [MetaMainDecorator.MetaInterface]: MetaMainType.interface,
+    [MetaMainDecorator.MetaMainInterface]: MetaMainType.mainInterface,
+};

package/dist/meta/meta.names.d.ts

@@ -0,0 +1,8 @@
+import { MetaFileType } from "./meta.enum.js";
+import { MetaNames } from "./meta.types.js";
+export declare const metaRename: (name: string, type: MetaFileType | string) => string;
+export declare const metaBasename: (name: string) => string;
+export declare const isMetaNameType: (name: string, type: MetaFileType) => boolean;
+export declare const metaNames: (basename: string) => MetaNames;
+export declare const metaFrontendNames: (basename: string) => MetaNames;
+export declare const metaBackendNames: (basename: string) => MetaNames;

package/dist/meta/meta.names.js

@@ -0,0 +1,35 @@
+import { lowerFirstLetter, TargetType, upperFirstLetter, } from "./meta.common.js";
+import { MetaFileType } from "./meta.enum.js";
+export const metaRename = (name, type) => `${metaBasename(name)}${upperFirstLetter(type)}`;
+export const metaBasename = (name) => {
+    for (const type of Object.values(MetaFileType)) {
+        if (isMetaNameType(name, type))
+            return `${name.substring(0, name.length - type.length)}`;
+    }
+    return name.substring(0);
+};
+export const isMetaNameType = (name, type) => name.endsWith(upperFirstLetter(type));
+export const metaNames = (basename) => ({
+    basename,
+    targetType: TargetType.common,
+    template: metaRename(basename, MetaFileType.template),
+    doc: metaRename(basename, MetaFileType.doc),
+    routes: metaRename(basename, MetaFileType.routes),
+    api: "",
+    func: "",
+    store: metaRename(basename, "store"),
+    shape: lowerFirstLetter(metaRename(basename, "shape")),
+    schema: lowerFirstLetter(metaRename(basename, "schema")),
+});
+export const metaFrontendNames = (basename) => ({
+    ...metaNames(basename),
+    targetType: TargetType.frontend,
+    api: metaRename(basename, "feApi"),
+    func: metaRename(basename, "feFunction"),
+});
+export const metaBackendNames = (basename) => ({
+    ...metaNames(basename),
+    targetType: TargetType.frontend,
+    api: metaRename(basename, "beApi"),
+    func: metaRename(basename, "beFunction"),
+});

package/dist/meta/meta.properties.d.ts

@@ -0,0 +1,62 @@
+import { MetaPropertyType } from "./meta.enum.js";
+import { MetaPropertyBaseOptions, WithoutBase, MetaKeyOptions, MetaCreateTimeOptions, MetaUpdateTimeOptions, MetaNumberOptions, MetaStringOptions, MetaArrayOptions, MetaObjectOptions, MetaDateOptions, MetaBooleanOptions } from "./meta.types.js";
+export type MetaPropertyDecoratorMap<DEF = any> = Record<MetaPropertyDecorator, DEF>;
+export type WithPropertyDecoratorMap<T, R extends MetaPropertyDecoratorMap<T>> = R;
+export declare enum MetaPropertyDecorator {
+    MetaKey = "MetaKey",
+    MetaCreateTime = "MetaCreateTime",
+    MetaUpdateTime = "MetaUpdateTime",
+    MetaNumber = "MetaNumber",
+    MetaString = "MetaString",
+    MetaArray = "MetaArray",
+    MetaObject = "MetaObject",
+    MetaDate = "MetaDate",
+    MetaBoolean = "MetaBoolean"
+}
+export declare const metaPropertyOptionsMap: MetaPropertyOptionsMap;
+export type MetaPropertyOptionsMap = WithPropertyDecoratorMap<MetaPropertyType, {
+    [MetaPropertyDecorator.MetaKey]: MetaPropertyType.key;
+    [MetaPropertyDecorator.MetaCreateTime]: MetaPropertyType.createTime;
+    [MetaPropertyDecorator.MetaUpdateTime]: MetaPropertyType.updateTime;
+    [MetaPropertyDecorator.MetaNumber]: MetaPropertyType.number;
+    [MetaPropertyDecorator.MetaString]: MetaPropertyType.string;
+    [MetaPropertyDecorator.MetaArray]: MetaPropertyType.array;
+    [MetaPropertyDecorator.MetaObject]: MetaPropertyType.object;
+    [MetaPropertyDecorator.MetaDate]: MetaPropertyType.date;
+    [MetaPropertyDecorator.MetaBoolean]: MetaPropertyType.boolean;
+}>;
+export type MetaPropertyOptionsBase = WithPropertyDecoratorMap<MetaPropertyBaseOptions, {
+    [MetaPropertyDecorator.MetaKey]: MetaKeyOptions;
+    [MetaPropertyDecorator.MetaCreateTime]: MetaCreateTimeOptions;
+    [MetaPropertyDecorator.MetaUpdateTime]: MetaUpdateTimeOptions;
+    [MetaPropertyDecorator.MetaNumber]: MetaNumberOptions;
+    [MetaPropertyDecorator.MetaString]: MetaStringOptions;
+    [MetaPropertyDecorator.MetaArray]: MetaArrayOptions;
+    [MetaPropertyDecorator.MetaObject]: MetaObjectOptions;
+    [MetaPropertyDecorator.MetaDate]: MetaDateOptions;
+    [MetaPropertyDecorator.MetaBoolean]: MetaBooleanOptions;
+}>;
+export type MetaPropertyOptions = Partial<WithPropertyDecoratorMap<WithoutBase<MetaPropertyBaseOptions>, {
+    [MetaPropertyDecorator.MetaKey]: WithoutBase<MetaPropertyOptionsBase[MetaPropertyDecorator.MetaKey]>;
+    [MetaPropertyDecorator.MetaCreateTime]: WithoutBase<MetaPropertyOptionsBase[MetaPropertyDecorator.MetaCreateTime]>;
+    [MetaPropertyDecorator.MetaUpdateTime]: WithoutBase<MetaPropertyOptionsBase[MetaPropertyDecorator.MetaUpdateTime]>;
+    [MetaPropertyDecorator.MetaNumber]: WithoutBase<MetaPropertyOptionsBase[MetaPropertyDecorator.MetaNumber]>;
+    [MetaPropertyDecorator.MetaString]: WithoutBase<MetaPropertyOptionsBase[MetaPropertyDecorator.MetaString]>;
+    [MetaPropertyDecorator.MetaArray]: WithoutBase<MetaPropertyOptionsBase[MetaPropertyDecorator.MetaArray]>;
+    [MetaPropertyDecorator.MetaObject]: WithoutBase<MetaPropertyOptionsBase[MetaPropertyDecorator.MetaObject]>;
+    [MetaPropertyDecorator.MetaDate]: WithoutBase<MetaPropertyOptionsBase[MetaPropertyDecorator.MetaDate]>;
+    [MetaPropertyDecorator.MetaBoolean]: WithoutBase<MetaPropertyOptionsBase[MetaPropertyDecorator.MetaBoolean]>;
+}>>;
+export interface MetaPropertyData extends MetaPropertyBaseOptions, MetaPropertyOptions {
+    propertyKey: string;
+    propertyType: string;
+}
+export declare const castMetaPropertyNumber: (prop: MetaPropertyData) => MetaNumberOptions | null;
+export declare const castMetaPropertyKey: (prop: MetaPropertyData) => MetaKeyOptions | null;
+export declare const castMetaPropertyCreateTime: (prop: MetaPropertyData) => MetaCreateTimeOptions | null;
+export declare const castMetaPropertyUpdateTime: (prop: MetaPropertyData) => MetaUpdateTimeOptions | null;
+export declare const castMetaPropertyString: (prop: MetaPropertyData) => MetaStringOptions | null;
+export declare const castMetaPropertyArray: (prop: MetaPropertyData) => MetaArrayOptions | null;
+export declare const castMetaPropertyObject: (prop: MetaPropertyData) => MetaObjectOptions | null;
+export declare const castMetaPropertyDate: (prop: MetaPropertyData) => MetaDateOptions | null;
+export declare const castMetaPropertyBoolean: (prop: MetaPropertyData) => MetaBooleanOptions | null;

package/dist/meta/meta.properties.js

@@ -0,0 +1,37 @@
+import { MetaPropertyType } from "./meta.enum.js";
+export var MetaPropertyDecorator;
+(function (MetaPropertyDecorator) {
+    MetaPropertyDecorator["MetaKey"] = "MetaKey";
+    MetaPropertyDecorator["MetaCreateTime"] = "MetaCreateTime";
+    MetaPropertyDecorator["MetaUpdateTime"] = "MetaUpdateTime";
+    MetaPropertyDecorator["MetaNumber"] = "MetaNumber";
+    MetaPropertyDecorator["MetaString"] = "MetaString";
+    MetaPropertyDecorator["MetaArray"] = "MetaArray";
+    MetaPropertyDecorator["MetaObject"] = "MetaObject";
+    MetaPropertyDecorator["MetaDate"] = "MetaDate";
+    MetaPropertyDecorator["MetaBoolean"] = "MetaBoolean";
+})(MetaPropertyDecorator || (MetaPropertyDecorator = {}));
+export const metaPropertyOptionsMap = {
+    [MetaPropertyDecorator.MetaKey]: MetaPropertyType.key,
+    [MetaPropertyDecorator.MetaCreateTime]: MetaPropertyType.createTime,
+    [MetaPropertyDecorator.MetaUpdateTime]: MetaPropertyType.updateTime,
+    [MetaPropertyDecorator.MetaNumber]: MetaPropertyType.number,
+    [MetaPropertyDecorator.MetaString]: MetaPropertyType.string,
+    [MetaPropertyDecorator.MetaArray]: MetaPropertyType.array,
+    [MetaPropertyDecorator.MetaObject]: MetaPropertyType.object,
+    [MetaPropertyDecorator.MetaDate]: MetaPropertyType.date,
+    [MetaPropertyDecorator.MetaBoolean]: MetaPropertyType.boolean,
+};
+export const castMetaPropertyNumber = (prop) => prop.type === MetaPropertyType.number ? prop : null;
+export const castMetaPropertyKey = (prop) => prop.type === MetaPropertyType.key ? prop : null;
+export const castMetaPropertyCreateTime = (prop) => prop.type === MetaPropertyType.createTime
+    ? prop
+    : null;
+export const castMetaPropertyUpdateTime = (prop) => prop.type === MetaPropertyType.updateTime
+    ? prop
+    : null;
+export const castMetaPropertyString = (prop) => prop.type === MetaPropertyType.string ? prop : null;
+export const castMetaPropertyArray = (prop) => prop.type === MetaPropertyType.array ? prop : null;
+export const castMetaPropertyObject = (prop) => prop.type === MetaPropertyType.object ? prop : null;
+export const castMetaPropertyDate = (prop) => prop.type === MetaPropertyType.date ? prop : null;
+export const castMetaPropertyBoolean = (prop) => prop.type === MetaPropertyType.boolean ? prop : null;