@sprucelabs/spruce-templates 24.1.33 → 25.0.0

package/build/esm/addons/importRelatedSchemas.addon.js

@@ -0,0 +1,34 @@
+import { SchemaField } from '@sprucelabs/schema';
+import handlebars from 'handlebars';
+import { camelCase, uniq } from 'lodash';
+handlebars.registerHelper('importRelatedSchemas', function (schema, options) {
+    var _a;
+    if (!schema) {
+        throw new Error('importRelatedSchemas needs a Schema as the first arg');
+    }
+    const { data: { root }, } = options;
+    const schemaTemplateItems = root === null || root === void 0 ? void 0 : root.schemaTemplateItems;
+    if (!schemaTemplateItems) {
+        throw new Error('importRelatedSchemas needs schemaTemplateItems passed to parent template');
+    }
+    const fields = schema.dynamicFieldSignature
+        ? [schema.dynamicFieldSignature]
+        : Object.values((_a = schema.fields) !== null && _a !== void 0 ? _a : {});
+    const imports = [];
+    fields.forEach((field) => {
+        if (field.type === 'schema') {
+            const related = SchemaField.mapFieldDefinitionToSchemaIdsWithVersion(field);
+            related.forEach((idWithVersion) => {
+                const matched = schemaTemplateItems.find((t) => t.id === idWithVersion.id &&
+                    t.schema.version === idWithVersion.version &&
+                    t.schema.namespace === idWithVersion.namespace);
+                if (matched) {
+                    imports.push(`import ${matched.nameCamel}Schema${matched.schema.version
+                        ? `_${matched.schema.version}`
+                        : ''} from '${matched.destinationDir}/${camelCase(matched.namespace)}${matched.schema.version ? `/${matched.schema.version}` : ''}/${matched.id}.schema'`);
+                }
+            });
+        }
+    });
+    return uniq(imports).join('\n');
+});

package/build/esm/addons/index.d.ts

@@ -0,0 +1,23 @@
+import './eq.addon';
+import './escape.addon';
+import './fieldDefinitionBodyPartial.addon';
+import './fieldDefinitionOptions.addon';
+import './fieldTypeEnum.addon';
+import './fieldValue.addon';
+import './gt.addon';
+import './hasKeys.addon';
+import './hasNoneCoreSchemaTemplateItems.addon';
+import './importRelatedSchemas.addon';
+import './index';
+import './isDefined.addon';
+import './json.addon';
+import './neq.addon';
+import './operators.addon';
+import './pascalCase.addon';
+import './permissionContractBuilder.addon';
+import './schemaBodyPartial.addon';
+import './schemaNamespacePath.addon';
+import './schemaValuesPartial.addon';
+import './valueTypeGenerator.addon';
+import './valueTypeLiteral.addon';
+import './valueTypeMapper.addon';

package/build/esm/addons/index.js

@@ -0,0 +1,23 @@
+import './eq.addon';
+import './escape.addon';
+import './fieldDefinitionBodyPartial.addon';
+import './fieldDefinitionOptions.addon';
+import './fieldTypeEnum.addon';
+import './fieldValue.addon';
+import './gt.addon';
+import './hasKeys.addon';
+import './hasNoneCoreSchemaTemplateItems.addon';
+import './importRelatedSchemas.addon';
+import './index';
+import './isDefined.addon';
+import './json.addon';
+import './neq.addon';
+import './operators.addon';
+import './pascalCase.addon';
+import './permissionContractBuilder.addon';
+import './schemaBodyPartial.addon';
+import './schemaNamespacePath.addon';
+import './schemaValuesPartial.addon';
+import './valueTypeGenerator.addon';
+import './valueTypeLiteral.addon';
+import './valueTypeMapper.addon';

package/build/esm/addons/isDefined.addon.d.ts

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

package/build/esm/addons/isDefined.addon.js

@@ -0,0 +1,5 @@
+import handlebars from 'handlebars';
+/* Quick way to do an equals check against 2 values */
+handlebars.registerHelper('isDefined', function (value) {
+    return value !== undefined;
+});

package/build/esm/addons/json.addon.d.ts

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

package/build/esm/addons/json.addon.js

@@ -0,0 +1,7 @@
+import handlebars from 'handlebars';
+/* Quick way to do an equals check against 2 values */
+handlebars.registerHelper('json', function (arg1) {
+    //@ts-ignore // TODO how should this work in a typed environment?
+    const value = JSON.stringify(arg1);
+    return value;
+});

package/build/esm/addons/neq.addon.d.ts

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

package/build/esm/addons/neq.addon.js

@@ -0,0 +1,4 @@
+import handlebars from 'handlebars';
+handlebars.registerHelper('neq', (val1, val2) => {
+    return val1 !== val2;
+});

package/build/esm/addons/operators.addon.d.ts

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

package/build/esm/addons/operators.addon.js

@@ -0,0 +1,15 @@
+import handlebars from 'handlebars';
+handlebars.registerHelper({
+    eq: (v1, v2) => v1 === v2,
+    ne: (v1, v2) => v1 !== v2,
+    lt: (v1, v2) => v1 < v2,
+    gt: (v1, v2) => v1 > v2,
+    lte: (v1, v2) => v1 <= v2,
+    gte: (v1, v2) => v1 >= v2,
+    and(...params) {
+        return Array.prototype.every.call(params, Boolean);
+    },
+    or(...params) {
+        return Array.prototype.slice.call(params, 0, -1).some(Boolean);
+    },
+});

package/build/esm/addons/pascalCase.addon.d.ts

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

package/build/esm/addons/pascalCase.addon.js

@@ -0,0 +1,6 @@
+import handlebars from 'handlebars';
+import { upperFirst } from 'lodash';
+/* Start case (cap first letter, lower rest) */
+handlebars.registerHelper('pascalCase', (val) => {
+    return upperFirst(val);
+});

package/build/esm/addons/permissionContractBuilder.addon.d.ts

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

package/build/esm/addons/permissionContractBuilder.addon.js

@@ -0,0 +1,4 @@
+import handlebars from 'handlebars';
+handlebars.registerHelper('permissionContractBuilder', function (permissionContract) {
+    return `buildPermissionContract(${JSON.stringify(permissionContract, null, 2)})`;
+});

package/build/esm/addons/schemaBodyPartial.addon.d.ts

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

package/build/esm/addons/schemaBodyPartial.addon.js

@@ -0,0 +1,8 @@
+import path from 'path';
+import fs from 'fs-extra';
+import handlebars from 'handlebars';
+const templatePath = path.join(__dirname, '..', 'templates', 'typescript');
+const schemaBodyPartial = fs
+    .readFileSync(path.join(templatePath, 'schema/partials/schemaBody.ts.hbs'))
+    .toString();
+handlebars.registerPartial('schemaBody', schemaBodyPartial);

package/build/esm/addons/schemaNamespacePath.addon.d.ts

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

package/build/esm/addons/schemaNamespacePath.addon.js

@@ -0,0 +1,18 @@
+import handlebars from 'handlebars';
+handlebars.registerHelper('schemaNamespacePath', function (options) {
+    var _a, _b;
+    const { schemaTemplateItem } = options.hash;
+    if (!schemaTemplateItem) {
+        throw new Error(`schemaNamespacePath needs schemaTemplateItem=item`);
+    }
+    const { globalSchemaNamespace } = (_b = (_a = options === null || options === void 0 ? void 0 : options.data) === null || _a === void 0 ? void 0 : _a.root) !== null && _b !== void 0 ? _b : {};
+    if (!globalSchemaNamespace) {
+        throw new Error('schemaNamespacePath template addon needs globalSchemaNamespace in the root context.');
+    }
+    let path = `${globalSchemaNamespace}.${schemaTemplateItem.namespace}`;
+    if (schemaTemplateItem.schema.version) {
+        path += `.${schemaTemplateItem.schema.version}`;
+    }
+    path += `.${schemaTemplateItem.namePascal}`;
+    return path;
+});

package/build/esm/addons/schemaValuesPartial.addon.d.ts

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

package/build/esm/addons/schemaValuesPartial.addon.js

@@ -0,0 +1,8 @@
+import path from 'path';
+import fs from 'fs-extra';
+import handlebars from 'handlebars';
+const templatePath = path.join(__dirname, '..', 'templates', 'typescript');
+const schemaValuesPartial = fs
+    .readFileSync(path.join(templatePath, 'schema/partials/schemaValues.ts.hbs'))
+    .toString();
+handlebars.registerPartial('schemaValues', schemaValuesPartial);

package/build/esm/addons/valueTypeGenerator.addon.d.ts

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

package/build/esm/addons/valueTypeGenerator.addon.js

@@ -0,0 +1,15 @@
+import handlebars from 'handlebars';
+import { upperFirst } from 'lodash';
+handlebars.registerHelper('valueTypeGenerator', function (fieldDefinition, renderAs, func, options) {
+    const { data: { root: { fieldTemplateItems }, }, } = options;
+    const match = fieldTemplateItems.filter((item) => item.camelType === fieldDefinition.type)[0];
+    if (!match) {
+        throw new Error(`valueTypeGenerator.addon could not find a fieldTemplateItem with type ${fieldDefinition.type}`);
+    }
+    const type = handlebars.helpers.fieldTypeEnum(fieldDefinition, options);
+    const fieldDefinitionCopy = Object.assign({}, fieldDefinition);
+    // @ts-ignore
+    fieldDefinitionCopy === null || fieldDefinitionCopy === void 0 ? true : delete fieldDefinitionCopy.keyName;
+    const def = JSON.stringify(Object.assign(Object.assign({}, fieldDefinitionCopy), { type: '{{TYPE_ENUM}}' })).replace('"{{TYPE_ENUM}}"', type);
+    return `${func}(${def}, TemplateRenderAs.${upperFirst(renderAs)}, "${match.importAs}")`;
+});

package/build/esm/addons/valueTypeLiteral.addon.d.ts

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

package/build/esm/addons/valueTypeLiteral.addon.js

@@ -0,0 +1,32 @@
+import { TemplateRenderAs } from '@sprucelabs/schema';
+import { SCHEMA_VERSION_FALLBACK } from '@sprucelabs/spruce-skill-utils';
+import handlebars from 'handlebars';
+/* The type for the value of a field. the special case is if the field is of type schema, then we get the target's interface */
+handlebars.registerHelper('valueTypeLiteral', function (namespace, nameCamel, version, fieldName, renderAs, options) {
+    var _a, _b, _c, _d;
+    if (!namespace) {
+        throw new Error('valueTypeLiteral needs namespace as 1st argument');
+    }
+    if (!nameCamel) {
+        throw new Error('valueTypeLiteral needs nameCamel as 2st argument');
+    }
+    if (!fieldName) {
+        throw new Error('valueTypeLiteral needs fieldName as 3st argument');
+    }
+    if (renderAs !== TemplateRenderAs.Value &&
+        renderAs !== TemplateRenderAs.Type &&
+        renderAs !== TemplateRenderAs.SchemaType) {
+        throw new Error('valueTypeLiteral helper needs renderAs to be "TemplateRenderAs.Type" or "TemplateRenderAs.Value" or "TemplateRenderAs.schemaType"');
+    }
+    const { data: { root }, } = options;
+    const valueTypes = root === null || root === void 0 ? void 0 : root.valueTypes;
+    if (!valueTypes) {
+        throw new Error('valueTypeLiteral helper needs a valuesTypes in the root context');
+    }
+    const v = version ? version : SCHEMA_VERSION_FALLBACK;
+    const valueType = (_d = (_c = (_b = (_a = valueTypes[namespace]) === null || _a === void 0 ? void 0 : _a[nameCamel]) === null || _b === void 0 ? void 0 : _b[v]) === null || _c === void 0 ? void 0 : _c[fieldName]) === null || _d === void 0 ? void 0 : _d.valueTypes[renderAs];
+    if (!valueType) {
+        throw new Error(`Unable to render value type for field "${namespace}.${nameCamel}.${v}.${fieldName}"`);
+    }
+    return valueType;
+});

package/build/esm/addons/valueTypeMapper.addon.d.ts

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

package/build/esm/addons/valueTypeMapper.addon.js

@@ -0,0 +1,9 @@
+import handlebars from 'handlebars';
+handlebars.registerHelper('valueTypeMapper', function (typeMapper, renderAs) {
+    if (renderAs === 'typeOnly') {
+        return typeMapper.split('<')[0];
+    }
+    else {
+        return typeMapper;
+    }
+});

package/build/esm/index.d.ts

@@ -0,0 +1,141 @@
+import { PermissionContractMap } from '@sprucelabs/mercury-types';
+import { Schema, SchemaTemplateItem, FieldTemplateItem } from '@sprucelabs/schema';
+import { TemplateRenderAs } from '@sprucelabs/schema';
+import handlebars from 'handlebars';
+import { FieldDefinitions } from '#spruce/schemas/fields/fields.types';
+import { DirectoryTemplateCode, DirectoryTemplateContextMap, ValueTypes, SchemaBuilderTemplateItem, ErrorOptions, ErrorTemplateItem, TestOptions, EventListenerOptions, EventContractTemplateItem, EventPayloadOptions, StoreTemplateOptions, StoreTemplateItem, ViewsOptions as CombinedViewsOptions, ListenerTemplateItem } from './types/templates.types';
+import './addons';
+export declare const templates: {
+    schemasTypes(options: {
+        schemaTemplateItems: SchemaTemplateItem[];
+        fieldTemplateItems: FieldTemplateItem[];
+        valueTypes: ValueTypes;
+        globalSchemaNamespace?: string;
+        typesTemplate?: string;
+    }): string;
+    valueTypes(options: {
+        schemaTemplateItems: SchemaTemplateItem[];
+        fieldTemplateItems: FieldTemplateItem[];
+        globalSchemaNamespace?: string;
+    }): string;
+    schema(options: SchemaTemplateItem & {
+        schemaTemplateItems: SchemaTemplateItem[];
+        fieldTemplateItems: FieldTemplateItem[];
+        valueTypes: ValueTypes;
+        globalSchemaNamespace?: string;
+        registerBuiltSchemas: boolean;
+        schemaFile?: string;
+        typesFile?: string;
+    }): string;
+    schemaBuilder(options: SchemaBuilderTemplateItem): string;
+    error(options: ErrorOptions): string;
+    errorOptionsTypes(options: {
+        options: ErrorTemplateItem[];
+    }): string;
+    schemaExample(options: {
+        nameCamel: string;
+        namePascal: string;
+        definition: Schema;
+    }): string;
+    schemaPlugin(): string;
+    errorPlugin(): string;
+    conversationPlugin(): string;
+    deployPlugin(): string;
+    errorExample(options: {
+        nameCamel: string;
+        namePascal: string;
+        definition: Schema;
+    }): string;
+    test(options: TestOptions): string;
+    fieldsTypes(options: {
+        fieldTemplateItems: FieldTemplateItem[];
+    }): string;
+    fieldClassMap(options: {
+        fieldTemplateItems: FieldTemplateItem[];
+    }): string;
+    launchConfig(): string;
+    vsCodeSettings(): Promise<string>;
+    listener(options: EventListenerOptions): string;
+    listeners(options: {
+        listeners: ListenerTemplateItem[];
+    }): string;
+    eventContract(options: EventContractTemplateItem & {
+        schemaTemplateItems: SchemaTemplateItem[];
+    }): string;
+    eventOptions(options: {
+        isGlobal: boolean;
+    }): string;
+    permissionPlugin(): string;
+    permissions(options: {
+        contracts: {
+            path: string;
+            nameCamel: string;
+        }[];
+    }): string;
+    permissionContractBuilder(options: {
+        nameCamel: string;
+        nameKebab: string;
+        nameReadable: string;
+        description?: string;
+    }): string;
+    permissionTypes(options: {
+        contracts: PermissionContractMap;
+    }): string;
+    eventEmitPayload(options: EventPayloadOptions): string;
+    eventEmitTarget(options: EventPayloadOptions): string;
+    eventResponsePayload(options: EventPayloadOptions): string;
+    combinedEventsContract(options: {
+        templateItems: EventContractTemplateItem[];
+        shouldImportCoreEvents?: boolean;
+        skillEventContractTypesFile: string;
+    }): string;
+    sandboxWillBootListener(): string;
+    polish(): string;
+    directoryTemplate<K extends DirectoryTemplateCode>(options: {
+        kind: K;
+        context: DirectoryTemplateContextMap[K];
+    }): Promise<(import("./types/templates.types").DirectoryTemplateFile & {
+        contents: string;
+    })[]>;
+    isValidTemplatedDirectory(options: {
+        kind: DirectoryTemplateCode;
+        dir: string;
+    }): Promise<boolean>;
+    conversationTopic(options: {
+        nameReadable: string;
+    }): string;
+    generateFieldKey(renderAs: TemplateRenderAs, definition: FieldDefinitions): string;
+    storePlugin(): string;
+    store(options: StoreTemplateOptions): string;
+    storeTypes(options: {
+        stores: StoreTemplateItem[];
+    }): string;
+    stores(options: {
+        stores: StoreTemplateItem[];
+    }): string;
+    skillViewController(options: {
+        namePascal: string;
+        nameKebab: string;
+    }): string;
+    viewController(options: {
+        viewModel: string;
+        namePascal: string;
+        nameKebab: string;
+    }): string;
+    appController(options: {
+        id: string;
+        namespacePascal: string;
+    }): string;
+    views(options: CombinedViewsOptions): string;
+    viewPlugin(): string;
+    viewControllerPlugin(options: {
+        namePascal: string;
+        nameCamel: string;
+    }): string;
+    theme(): string;
+    logTransport(): string;
+};
+export type Templates = typeof templates;
+export { default as importExtractorUtil } from './utilities/importExtractor.utility';
+export default handlebars;
+export * from './types/templates.types';