@hyperweb/telescope 2.1.0 → 2.2.0

package/src/build.ts

@@ -1,255 +0,0 @@
-import { ProtoRef, TelescopeOptions } from '@cosmology/types';
-import { ProtoStore } from '@cosmology/proto-parser';
-import {
-    AminoParseContext,
-    createAminoConverter,
-    createCreateProtoType,
-    createObjectWithMethods,
-    createRegisterObject,
-    createProtoEnum,
-    createProtoEnumToJSON,
-    createProtoEnumFromJSON,
-    createProtoType,
-    createProtoInterfaceEncodedType,
-    createProtoTypeType,
-    createSDKType,
-    createAminoType,
-    createAminoTypeType,
-    createEnumSDKType,
-    createEnumAminoType,
-    makeAminoTypeInterface,
-    GenericParseContext,
-    ProtoParseContext,
-    createTypeRegistry,
-    createRegistryLoader,
-
-    // helper
-    createHelperObject,
-    createInterfaceDecoder,
-    createInterfaceFromAmino,
-    createInterfaceToAmino,
-    createRegisterAminoProtoMapping,
-} from '@cosmology/ast';
-import { ServiceMutation, ServiceQuery } from '@cosmology/types';
-
-export const getMutations = (mutations: ServiceMutation[]) => {
-    return mutations.map((mutation: ServiceMutation) => {
-        return {
-            typeUrl: `/${mutation.package}.${mutation.message}`,
-            TypeName: mutation.message,
-            methodName: mutation.methodName
-        }
-    });
-};
-
-export const getAminoProtos = (mutations: ServiceMutation[], store: ProtoStore) => {
-    return mutations.map(mutation => {
-        const ref = store.findProto(mutation.messageImport);
-        return store.get(ref, mutation.message).obj;
-    });
-};
-
-export const buildBaseTypeScriptClass = (
-    context: TelescopeParseContext,
-    name: string,
-    obj: any
-) => {
-    if (context.options.prototypes.enabled) {
-        context.body.push(createCreateProtoType(context.proto, name, obj));
-        context.body.push(createObjectWithMethods(context.proto, name, obj));
-
-        if(context.options.interfaces?.enabled && context.options.interfaces?.useGlobalDecoderRegistry && context.options.interfaces?.registerAllDecodersToGlobal){
-          const registerObj = createRegisterObject(context.proto, name, obj);
-          if(registerObj){
-            context.body.push(registerObj);
-
-            //createRegisterAminoProtoMapping
-            const registerAminoObj = createRegisterAminoProtoMapping(context.proto, name, obj);
-            if(registerAminoObj){
-              context.body.push(registerAminoObj);
-            }
-          }
-        }
-    }
-};
-
-export const buildBaseTypeScriptInterface = (
-    context: TelescopeParseContext,
-    name: string,
-    obj: any
-) => {
-
-    context.body.push(createProtoType(context.proto, name, obj));
-
-    if (context.options.aminoEncoding?.enabled && !context.options.aminoEncoding?.useLegacyInlineEncoding || context.options.prototypes?.methods?.fromProto || context.options.prototypes?.methods?.toProto) {
-        context.body.push(createProtoTypeType(context.proto, name, obj));
-    }
-
-    if (context.options.aminoEncoding?.enabled && !context.options.aminoEncoding?.useLegacyInlineEncoding) {
-        // conditional type
-        const interfaceType = createProtoInterfaceEncodedType(context.proto, name, obj);
-        if (interfaceType) {
-            context.body.push(interfaceType);
-        }
-        context.body.push(createAminoType(context.proto, name, obj));
-
-        if(!context.options.aminoEncoding?.disableMsgTypes){
-            context.body.push(createAminoTypeType(context.proto, name, obj));
-        }
-    }
-    if (context.options.useSDKTypes) {
-        context.body.push(createSDKType(context.proto, name, obj));
-    }
-};
-
-export const buildEnums = (
-    context: TelescopeParseContext,
-    name: string,
-    obj: any
-) => {
-    context.body.push(createProtoEnum(context.proto, name, obj));
-    if (context.options.useSDKTypes) {
-        context.body.push(createEnumSDKType(context.proto, name, obj));
-    }
-    if (context.options.aminoEncoding?.enabled && !context.options.aminoEncoding?.useLegacyInlineEncoding) {
-        context.body.push(createEnumAminoType(context.proto, name, obj));
-    }
-    context.body.push(createProtoEnumFromJSON(context.proto, name, obj));
-    context.body.push(createProtoEnumToJSON(context.proto, name, obj));
-};
-export interface TelescopeParseContext {
-    options: TelescopeOptions;
-    generic: GenericParseContext;
-    proto: ProtoParseContext;
-    amino: AminoParseContext;
-    store: ProtoStore;
-    ref: ProtoRef;
-    parsedImports: Record<string, any>;
-    body: any[];
-    mutations: ServiceMutation[];
-    queries: any[];
-    services: any[];
-    types: any[];
-}
-export class TelescopeParseContext implements TelescopeParseContext {
-    constructor(ref: ProtoRef, store: ProtoStore, options: TelescopeOptions) {
-        this.generic = new GenericParseContext(
-            ref, store, options
-        );
-        this.proto = new ProtoParseContext(
-            ref, store, options
-        );
-        this.amino = new AminoParseContext(
-            ref, store, options
-        );
-        this.options = options;
-        this.ref = ref;
-        this.store = store;
-        this.parsedImports = {};
-        this.body = [];
-        this.queries = [];
-        this.services = [];
-        this.mutations = [];
-        this.types = [];
-    }
-
-    hasMutations() {
-        return this.mutations.length > 0;
-    }
-
-    addType(name: string, obj: any, isNested: boolean) {
-        this.types.push({
-            name,
-            obj,
-            isNested
-        });
-    }
-    addMutation(mutation: ServiceMutation) {
-        this.mutations.push(mutation);
-    }
-    addQuery(query: ServiceQuery) {
-        this.queries.push(query);
-    }
-    addService(query: any) {
-        this.services.push(query);
-    }
-    // build main Class with methods
-    buildBase() {
-        this.types.forEach(typeReg => {
-            const { name, obj } = typeReg;
-            if (obj.type === 'Enum') {
-                buildEnums(this, name, obj);
-            }
-        });
-        this.types.forEach(typeReg => {
-            const { name, obj } = typeReg;
-            if (obj.type === 'Type') {
-                buildBaseTypeScriptInterface(this, name, obj);
-            }
-        });
-        this.types.forEach(typeReg => {
-            const { name, obj } = typeReg;
-            if (obj.type === 'Type') {
-                buildBaseTypeScriptClass(this, name, obj);
-            }
-        });
-
-        // interfaces
-        if (this.options.interfaces.enabled && !this.options.interfaces.useGlobalDecoderRegistry) {
-            const interfaces = Object.keys(this.ref.traversed.acceptsInterface ?? {});
-            if (interfaces.length) {
-                interfaces.forEach(interfaceName => {
-                    this.body.push(createInterfaceDecoder(this.proto, this.ref, interfaceName));
-                    if (
-                        this.options.aminoEncoding?.enabled &&
-                        !this.options.aminoEncoding?.useLegacyInlineEncoding
-                    ) {
-                        this.body.push(createInterfaceFromAmino(this.proto, this.ref, interfaceName));
-                        this.body.push(createInterfaceToAmino(this.proto, this.ref, interfaceName));
-                    }
-                })
-            }
-        }
-    }
-
-    buildRegistry() {
-        this.body.push(createTypeRegistry(this.amino, getMutations(this.mutations)));
-    }
-    buildRegistryLoader() {
-        if (!this.options?.prototypes?.enableRegistryLoader) {
-          return
-        }
-
-        this.body.push(createRegistryLoader(this.amino));
-    }
-    buildAminoInterfaces() {
-        if (!this.options?.aminoEncoding?.enabled || !this.options?.aminoEncoding?.useLegacyInlineEncoding) return;
-        //
-        const protos = getAminoProtos(this.mutations, this.store);
-        protos.forEach(proto => {
-            this.body.push(makeAminoTypeInterface({
-                context: this.amino,
-                proto
-            }));
-        });
-    }
-    buildAminoConverter() {
-        this.body.push(createAminoConverter({
-            name: 'AminoConverter',
-            context: this.amino,
-            root: this.ref.traversed,
-            protos: getAminoProtos(this.mutations, this.store)
-        }));
-    }
-    buildHelperObject() {
-        if (!this.options?.prototypes?.enableMessageComposer) {
-          return
-        }
-        // add methods
-        this.body.push(createHelperObject({
-            context: this.amino,
-            name: 'MessageComposer',
-            mutations: getMutations(this.mutations)
-        }));
-    }
-}

package/src/builder.ts

@@ -1,292 +0,0 @@
-import { ProtoStore } from '@cosmology/proto-parser';
-import { TelescopeParseContext } from './build';
-import { TelescopeOptions, defaultTelescopeOptions } from '@cosmology/types';
-import { toPosixPath } from '@cosmology/utils';
-import { bundlePackages } from './bundle';
-import { BundlerFile, TelescopeInput } from './types';
-import { Bundler } from './bundler';
-import deepmerge from 'deepmerge';
-import { resolve } from 'path';
-
-import { plugin as createTypes } from './generators/create-types';
-import { plugin as createAminoConverters } from './generators/create-amino-converters';
-import { plugin as createRegistries } from './generators/create-registries';
-import { plugin as createLCDClients } from './generators/create-lcd-clients';
-import { plugin as createAggregatedLCDClient } from './generators/create-aggregated-lcd-client';
-import { plugin as createLCDClientsScoped } from './generators/create-lcd-client-scoped';
-import { plugin as createLCDClientsAll } from './generators/create-lcd-client-all';
-import { plugin as createRPCQueryClientsScoped } from './generators/create-rpc-query-client-scoped';
-import { plugin as createRPCQueryClientsAll } from './generators/create-rpc-query-client-all';
-import { plugin as createRPCMsgClientsScoped } from './generators/create-rpc-msg-client-scoped';
-import { plugin as createRPCMsgClientsAll } from './generators/create-rpc-msg-client-all';
-import { plugin as createRPCQueryClients } from './generators/create-rpc-query-clients';
-import { plugin as createRPCMsgClients } from './generators/create-rpc-msg-clients';
-import { plugin as createQueryFuncs } from './generators/create-query-funcs';
-import { plugin as createMsgFuncs } from './generators/create-msg-funcs';
-import { plugin as createReactQueryBundle } from './generators/create-react-query-bundle';
-import { plugin as createMobxBundle } from './generators/create-mobx-bundle';
-import { plugin as createStargateClients } from './generators/create-stargate-clients';
-import { plugin as createCustomStargateClients } from './generators/create-custom-stargate-clients';
-import { plugin as createAllStargateClients } from './generators/create-all-stargate-clients';
-import { plugin as createSdkModuleStargateClients } from './generators/create-sdk-module-stargate-clients';
-import { plugin as createBundle } from './generators/create-bundle';
-import { plugin as createIndex } from './generators/create-index';
-import { plugin as createHelpers } from './generators/create-helpers';
-
-import { plugin as createPiniaStore } from './generators/create-pinia-store';
-import { plugin as createPiniaStoreBundle } from './generators/create-pinia-store-bundle';
-import { plugin as createRpcOpsBundle } from './generators/create-rpc-ops-bundle';
-import { plugin as customizeUtils } from './generators/customize-utils';
-import { plugin as createRootReadme } from './generators/create-root-readme';
-import { plugin as createMcpServer } from './generators/create-mcp-server';
-
-const sanitizeOptions = (options: TelescopeOptions): TelescopeOptions => {
-  // If an element at the same key is present for both x and y, the value from y will appear in the result.
-  options = deepmerge(defaultTelescopeOptions, options ?? {});
-
-  // strip off leading slashes
-  options.tsDisable.files = options.tsDisable.files.map((file) =>
-    file.startsWith('/') ? file : file.replace(/^\//, '')
-  );
-  options.eslintDisable.files = options.eslintDisable.files.map((file) =>
-    file.startsWith('/') ? file : file.replace(/^\//, '')
-  );
-  // uniq bc of deepmerge
-  options.rpcClients.enabledServices = [
-    ...new Set([...options.rpcClients.enabledServices]),
-  ];
-  return options;
-};
-
-export class TelescopeBuilder {
-  store: ProtoStore;
-  protoDirs: string[];
-  outPath: string;
-  options: TelescopeOptions;
-  contexts: TelescopeParseContext[] = [];
-  files: string[] = [];
-
-  readonly converters: BundlerFile[] = [];
-  readonly lcdClients: BundlerFile[] = [];
-  readonly rpcQueryClients: BundlerFile[] = [];
-  readonly rpcMsgClients: BundlerFile[] = [];
-  readonly registries: BundlerFile[] = [];
-  readonly stateManagers: Record<string, BundlerFile[]> = {};
-
-  // Function mapping storage: package -> service -> method -> functionName
-  readonly functionMappings: Record<string, Record<string, Record<string, {
-    functionName: string;
-    hookName: string;
-    comment?: string;
-    requestType: string;
-    responseType: string;
-    sourceFilename?: string;
-    hookSourceFilename?: string;
-    typeSourceFilename?: string;
-  }>>> = {};
-
-  constructor({
-    protoDirs,
-    outPath,
-    store,
-    options,
-  }: TelescopeInput & { store?: ProtoStore }) {
-    const fixedDirs = protoDirs.map((directory) => {
-      return toPosixPath(directory);
-    });
-
-    this.protoDirs = fixedDirs;
-    this.outPath = resolve(toPosixPath(outPath));
-    this.options = sanitizeOptions(options);
-    this.store = store ?? new ProtoStore(fixedDirs, this.options);
-    this.store.traverseAll();
-
-  }
-
-  context(ref) {
-    const ctx = new TelescopeParseContext(ref, this.store, this.options);
-    this.contexts.push(ctx);
-    return ctx;
-  }
-
-  addFunctionMapping(
-    packageName: string,
-    serviceName: string,
-    methodName: string,
-    functionName: string,
-    hookName: string,
-    comment?: string,
-    requestType?: string,
-    responseType?: string,
-    sourceFilename?: string,
-    hookSourceFilename?: string,
-    typeSourceFilename?: string
-  ) {
-    if (!this.functionMappings[packageName]) {
-      this.functionMappings[packageName] = {};
-    }
-    if (!this.functionMappings[packageName][serviceName]) {
-      this.functionMappings[packageName][serviceName] = {};
-    }
-
-    this.functionMappings[packageName][serviceName][methodName] = {
-      functionName,
-      hookName,
-      comment,
-      requestType,
-      responseType,
-      sourceFilename,
-      hookSourceFilename,
-      typeSourceFilename
-    };
-  }
-
-  getFunctionMappings() {
-    return this.functionMappings;
-  }
-
-  addStateManagers(type: string, files: BundlerFile[]) {
-    const state = this.stateManagers[type];
-
-    if (!state) {
-      this.stateManagers[type] = [];
-    }
-
-    [].push.apply(this.stateManagers[type], files);
-  }
-
-  addRPCQueryClients(files: BundlerFile[]) {
-    [].push.apply(this.rpcQueryClients, files);
-  }
-
-  addRPCMsgClients(files: BundlerFile[]) {
-    [].push.apply(this.rpcMsgClients, files);
-  }
-
-  addLCDClients(files: BundlerFile[]) {
-    [].push.apply(this.lcdClients, files);
-  }
-
-  addRegistries(files: BundlerFile[]) {
-    [].push.apply(this.registries, files);
-  }
-
-  addConverters(files: BundlerFile[]) {
-    [].push.apply(this.converters, files);
-  }
-
-
-
-
-  async build() {
-    // check warnings
-    if (
-      !this.options.aminoEncoding?.enabled &&
-      (this.options.prototypes?.methods?.fromAmino ||
-        this.options.prototypes?.methods?.toAmino)
-    ) {
-      console.warn(
-        "There could be compilation errors in generated code, because 'aminoEncoding.enabled: false' means amino types wouldn't be created, but 'toAmino' or 'fromAmino' need amino types."
-      );
-    }
-
-    if (!this.options.prototypes.methods.fromPartial) {
-      console.warn(
-        "The 'fromPartial' option will be deprecated in a future version. Encoder objects need fromPartial to be a creator function to create instance of the type. So it should always be left on, otherwise there could be compilation errors in generated code."
-      );
-    }
-
-    customizeUtils(this);
-
-    const allConverters = [];
-    const allRegistries = [];
-    // [x] get bundle of all packages
-    const bundles = bundlePackages(this.store).map((bundle) => {
-      // store bundleFile in filesToInclude
-      const bundler = new Bundler(this, bundle);
-
-
-      // [x] write out all TS files for package
-      createTypes(this, bundler);
-
-      // [x] write out one amino helper for all contexts w/mutations
-      createAminoConverters(this, bundler);
-
-      // [x] write out one registry helper for all contexts w/mutations
-      createRegistries(this, bundler);
-
-      // [x] write out one registry helper for all contexts w/mutations
-      createLCDClients(this, bundler);
-
-      createQueryFuncs(this, bundler);
-      createRPCQueryClients(this, bundler);
-      createMsgFuncs(this, bundler);
-      createRPCMsgClients(this, bundler);
-      createPiniaStore(this, bundler);
-
-      if (this.options.rpcClients.clientStyle.useUpdatedClientStyle) {
-        // generate sdk-module client file
-        if (this.options.rpcClients.clientStyle.type.includes('sdk-module-client') && this.options.rpcClients.clientStyle.sdkModuleClientOption.includes(bundler.bundle.base)) {
-          createSdkModuleStargateClients(this, bundler)
-        }
-
-        // store registry and converter for all/custom client generation
-        if (bundler.registries) {
-          allRegistries.push(...bundler.registries)
-        }
-        if (bundler.converters) {
-          allConverters.push(...bundler.converters)
-        }
-      } else {
-        // [x] write out one client for each base package, referencing the last two steps
-        createStargateClients(this, bundler);
-      }
-      return bundler;
-    });
-
-    if (this.options.rpcClients.clientStyle.useUpdatedClientStyle) {
-      // generate cutsom client file
-      if (this.options.rpcClients.clientStyle.type.includes('custom-client') && this.options.rpcClients.clientStyle.customClientOption && this.options.rpcClients.clientStyle.customClientOption.length !== 0) {
-        createCustomStargateClients(this, allRegistries, allConverters)
-      }
-      // generate all module client file
-      if (this.options.rpcClients.clientStyle.type.includes('all-client')) {
-        createAllStargateClients(this, allRegistries, allConverters)
-      }
-    }
-
-    // post run plugins
-    bundles.forEach((bundler) => {
-      createLCDClientsAll(this, bundler);
-      createLCDClientsScoped(this, bundler);
-      createRPCQueryClientsAll(this, bundler);
-      createRPCQueryClientsScoped(this, bundler);
-      createRPCMsgClientsAll(this, bundler);
-      createRPCMsgClientsScoped(this, bundler);
-      createBundle(this, bundler);
-    });
-
-    createRpcOpsBundle(this);
-    createReactQueryBundle(this);
-    createMobxBundle(this);
-    createAggregatedLCDClient(this);
-
-    createHelpers(this);
-    createPiniaStoreBundle(this);
-
-    // finally, write one index file with all files, exported
-    createIndex(this);
-    createRootReadme(this);
-
-    // Generate MCP server at the very end after all files are written
-    if (this.options.mcpServer?.enabled && bundles.length > 0) {
-      // Use the first bundle that has contexts (typically the main aggregated bundle)
-      const primaryBundle = bundles.find(bundler => bundler.contexts.length > 0);
-      if (primaryBundle) {
-        createMcpServer(this, primaryBundle);
-      }
-    }
-
-    console.log(`✨ files transpiled in '${this.outPath}'`);
-  }
-}

package/src/bundle.ts

@@ -1,160 +0,0 @@
-import { ProtoStore, isRefExcluded, createEmptyProtoRef } from '@cosmology/proto-parser';
-import { importNamespace } from '@cosmology/ast';
-import * as dotty from 'dotty';
-import { TelescopeBuilder } from './index';
-import { join, relative, dirname } from 'path';
-import { TelescopeParseContext } from './build';
-import { TelescopeOptions } from '@cosmology/types';
-import { toPosixPath } from '@cosmology/utils';
-
-// TODO move to store
-export const getPackages = (store: ProtoStore) => {
-    return store.getProtos().reduce((m, proto) => {
-        if (proto.proto.package) {
-            m[proto.proto.package] = m[proto.proto.package] || []
-            m[proto.proto.package].push(proto);
-        }
-        return m;
-    }, {});
-}
-
-export const getPackagesBundled = (store: ProtoStore) => {
-    const objectified = {};
-    const pkgs = getPackages(store);
-    Object.keys(pkgs).forEach(key => {
-        if (isRefExcluded(createEmptyProtoRef(key), store.options.prototypes?.excluded)) return;
-        const files = pkgs[key];
-        dotty.put(objectified, key, {
-            pkg: key,
-            files: files.filter(file => {
-                return !isRefExcluded(createEmptyProtoRef(key, file.filename), store.options.prototypes?.excluded);
-            })
-        });
-    });
-    return objectified;
-
-}
-
-export const bundlePackages = (store: ProtoStore) => {
-    const allPackages = getPackagesBundled(store);
-    return Object.keys(allPackages).map(base => {
-        const pkgs = allPackages[base];
-        const bundleVariables = {};
-        const bundleFile = toPosixPath(join(base, 'bundle.ts'));
-        const importPaths = [];
-        parsePackage(store.options, pkgs, bundleFile, importPaths, bundleVariables);
-        return {
-            bundleVariables,
-            bundleFile,
-            importPaths,
-            base
-        };
-    });
-};
-
-// TODO review bundle registry methods
-export const bundleRegistries = (telescope: TelescopeBuilder) => {
-    const withMutations = telescope.contexts.filter(
-        ctx => ctx.mutations.length
-    );
-    const obj = withMutations.reduce((m, ctx) => {
-        m[ctx.ref.proto.package] = m[ctx.ref.proto.package] ?? [];
-        m[ctx.ref.proto.package].push(ctx);
-        return m;
-    }, {});
-
-    return Object.entries(obj)
-        .map(([pkg, serviceProtos]) => {
-            return {
-                package: pkg,
-                contexts: serviceProtos
-            };
-        });
-}
-
-export const bundleBaseRegistries = (telescope: TelescopeBuilder) => {
-    const withMutations = telescope.contexts.filter(
-        ctx => ctx.mutations.length
-    );
-    const obj = withMutations.reduce((m, ctx) => {
-        const base = ctx.ref.proto.package.split('.')[0];
-        m[base] = m[base] ?? {};
-        m[base][ctx.ref.proto.package] = m[base][ctx.ref.proto.package] ?? [];
-        m[base][ctx.ref.proto.package].push(ctx);
-        return m;
-    }, {});
-
-    return Object.entries(obj)
-        .map(([pkg, withServices]) => {
-
-            const serviceProtos = Object.entries(withServices)
-                .map(([pkg, withServices]) => {
-                    return {
-                        package: pkg,
-                        contexts: withServices
-                    }
-                });
-
-
-            return {
-                base: pkg,
-                pkgs: serviceProtos
-            };
-        });
-};
-
-export const parseContextsForRegistry = (contexts: TelescopeParseContext[]) => {
-    return contexts.map((ctx: TelescopeParseContext) => {
-        const responses = ctx.mutations.map(m => m.response)
-        const imports = ctx.mutations.reduce((m, msg) => {
-            m[msg.messageImport] = m[msg.messageImport] ?? [];
-            m[msg.messageImport].push(msg.message);
-            return m;
-        }, {})
-
-        return {
-            filename: ctx.ref.filename,
-            imports,
-            objects: ctx.types
-                .filter(type => !type.isNested)
-                .filter(type => !responses.includes(type.name))
-                .map(type => type.name)
-        }
-    });
-};
-
-export const parsePackage = (
-    options: TelescopeOptions,
-    obj,
-    bundleFile,
-    importPaths,
-    bundleVariables
-) => {
-    if (!obj) return;
-    if (obj.pkg && obj.files) {
-        obj.files.forEach(file => {
-            createFileBundle(options, obj.pkg, file.filename, bundleFile, importPaths, bundleVariables);
-        });
-        return;
-    }
-    Object.keys(obj).forEach(mini => {
-        parsePackage(options, obj[mini], bundleFile, importPaths, bundleVariables);
-    })
-}
-
-let counter = 0;
-export const createFileBundle = (
-    options: TelescopeOptions,
-    pkg,
-    filename,
-    bundleFile,
-    importPaths,
-    bundleVariables
-) => {
-    let rel = relative(dirname(bundleFile), filename);
-    if (!rel.startsWith('.')) rel = `./${rel}`;
-    const variable = `_${counter++}`;
-    importPaths.push(importNamespace(variable, toPosixPath(rel)));
-    dotty.put(bundleVariables, pkg + '.__export', true);
-    dotty.put(bundleVariables, pkg + '.' + variable, true);
-}