@cedarjs/internal 0.6.0 → 0.6.1-next.51

package/dist/cjs/generate/plugins/rw-typescript-resolvers/visitor.js

@@ -0,0 +1,84 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var visitor_exports = {};
+__export(visitor_exports, {
+  RwTypeScriptResolversVisitor: () => RwTypeScriptResolversVisitor
+});
+module.exports = __toCommonJS(visitor_exports);
+var import_typescript_resolvers = require("@graphql-codegen/typescript-resolvers");
+var import_visitor_plugin_common = require("@graphql-codegen/visitor-plugin-common");
+class RwTypeScriptResolversVisitor extends import_typescript_resolvers.TypeScriptResolversVisitor {
+  constructor(pluginConfig, schema) {
+    super(pluginConfig, schema);
+  }
+  FieldDefinition(node, key, parent) {
+    const hasArguments = node.arguments && node.arguments.length > 0;
+    const superFieldDefinition = super.FieldDefinition(node, key, parent);
+    return (parentName) => {
+      const fieldDef = superFieldDefinition(parentName);
+      if (!hasArguments && fieldDef?.includes(": Resolver<")) {
+        return fieldDef.replace(": Resolver<", ": OptArgsResolverFn<");
+      }
+      return fieldDef;
+    };
+  }
+  // Original implementation is here:
+  // https://github.com/dotansimha/graphql-code-generator/blob/c6c60a3078f3797af435c3852220d8898964031d/packages/plugins/other/visitor-plugin-common/src/base-resolvers-visitor.ts#L1091
+  ObjectTypeDefinition(node) {
+    const originalBlock = super.ObjectTypeDefinition(node);
+    const name = this.convertName(node, {
+      suffix: this.config.resolverTypeSuffix
+    });
+    const typeName = node.name;
+    const parentType = this.getParentTypeToUse(typeName);
+    const fieldsContent = (node.fields || []).map((f) => f(node.name));
+    const isRootType = [
+      this.schema.getQueryType()?.name,
+      this.schema.getMutationType()?.name,
+      this.schema.getSubscriptionType()?.name
+    ].includes(typeName);
+    if (!isRootType) {
+      fieldsContent.push(
+        (0, import_visitor_plugin_common.indent)(
+          `${this.config.internalResolversPrefix}isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>${this.getPunctuation(
+            "type"
+          )}`
+        )
+      );
+    }
+    const blockRelationsResolver = new import_visitor_plugin_common.DeclarationBlock(
+      this._declarationBlockConfig
+    ).export().asKind("type").withName(
+      name.replace("Resolvers", "RelationResolvers"),
+      `<ContextType = ${this.config.contextType.type}, ${this.transformParentGenericType(parentType)}>`
+    ).withBlock(
+      fieldsContent.map(
+        (content) => content.replace(
+          /: (?:OptArgs)?Resolver(?:Fn)?/,
+          "?: RequiredResolverFn"
+        )
+      ).join("\n")
+    );
+    return originalBlock + "\n" + blockRelationsResolver.string;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RwTypeScriptResolversVisitor
+});

package/dist/cjs/generate/possibleTypes.d.ts

@@ -0,0 +1,36 @@
+type PossibleTypesResult = {
+    possibleTypesFiles: string[];
+    errors: {
+        message: string;
+        error: unknown;
+    }[];
+};
+/**
+ * Generate possible types from fragments and union types
+ *
+ * In order to use fragments with unions and interfaces in Apollo Client,
+ * you need to tell the client how to discriminate between the different
+ * types that implement or belong to a supertype.
+ *
+ * You pass a possibleTypes option to the InMemoryCache constructor
+ * to specify these relationships in your schema.
+ *
+ * This object maps the name of an interface or union type (the supertype)
+ * to the types that implement or belong to it (the subtypes).
+ *
+ * For example:
+ *
+ * ```ts
+ * possibleTypes: {
+ *  Character: ["Jedi", "Droid"],
+ *  Test: ["PassingTest", "FailingTest", "SkippedTest"],
+ *  Snake: ["Viper", "Python"],
+ *  Groceries: ['Fruit', 'Vegetable'],
+ * },
+ * ```
+ *
+ * @see https://www.apollographql.com/docs/react/data/fragments/#using-fragments-with-unions-and-interfaces
+ **/
+export declare const generatePossibleTypes: () => Promise<PossibleTypesResult>;
+export {};
+//# sourceMappingURL=possibleTypes.d.ts.map

package/dist/cjs/generate/possibleTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"possibleTypes.d.ts","sourceRoot":"","sources":["../../../src/generate/possibleTypes.ts"],"names":[],"mappings":"AAYA,KAAK,mBAAmB,GAAG;IACzB,kBAAkB,EAAE,MAAM,EAAE,CAAA;IAC5B,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,EAAE,CAAA;CAC9C,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;IAyBI;AACJ,eAAO,MAAM,qBAAqB,QAAa,OAAO,CAAC,mBAAmB,CAyEzE,CAAA"}

package/dist/cjs/generate/possibleTypes.js

@@ -0,0 +1,106 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var possibleTypes_exports = {};
+__export(possibleTypes_exports, {
+  generatePossibleTypes: () => generatePossibleTypes
+});
+module.exports = __toCommonJS(possibleTypes_exports);
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var fragmentMatcher = __toESM(require("@graphql-codegen/fragment-matcher"), 1);
+var import_graphql_file_loader = require("@graphql-tools/graphql-file-loader");
+var import_load = require("@graphql-tools/load");
+var import_prettier = require("prettier");
+var import_project_config = require("@cedarjs/project-config");
+var import_graphqlCodeGen = require("./graphqlCodeGen.js");
+const generatePossibleTypes = async () => {
+  const config = (0, import_project_config.getConfig)();
+  if (!config.graphql.fragments) {
+    return {
+      possibleTypesFiles: [],
+      errors: []
+    };
+  }
+  const filename = import_path.default.join((0, import_project_config.getPaths)().web.graphql, "possibleTypes.ts");
+  const options = (0, import_graphqlCodeGen.getLoadDocumentsOptions)(filename);
+  const documentsGlob = "./web/src/**/!(*.d).{ts,tsx,js,jsx}";
+  let documents;
+  try {
+    documents = await (0, import_load.loadDocuments)([documentsGlob], options);
+  } catch {
+    return {
+      possibleTypesFiles: [],
+      errors: []
+    };
+  }
+  const errors = [];
+  try {
+    const files = [];
+    const pluginConfig = {};
+    const info = {
+      outputFile: filename
+    };
+    const schema = (0, import_load.loadSchemaSync)((0, import_project_config.getPaths)().generated.schema, {
+      loaders: [new import_graphql_file_loader.GraphQLFileLoader()],
+      sort: true
+    });
+    const possibleTypes = await fragmentMatcher.plugin(
+      schema,
+      documents,
+      pluginConfig,
+      info
+    );
+    files.push(filename);
+    const output = await (0, import_prettier.format)(possibleTypes.toString(), {
+      trailingComma: "es5",
+      bracketSpacing: true,
+      tabWidth: 2,
+      semi: false,
+      singleQuote: true,
+      arrowParens: "always",
+      parser: "typescript"
+    });
+    import_fs.default.mkdirSync(import_path.default.dirname(filename), { recursive: true });
+    import_fs.default.writeFileSync(filename, output);
+    return { possibleTypesFiles: [filename], errors };
+  } catch (e) {
+    errors.push({
+      message: "Error: Could not generate GraphQL possible types (web)",
+      error: e
+    });
+    return {
+      possibleTypesFiles: [],
+      errors
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generatePossibleTypes
+});

package/dist/cjs/generate/templates/all-currentUser.d.ts.template

@@ -0,0 +1,30 @@
+import '@cedarjs/api'
+import '@cedarjs/auth'
+
+import { getCurrentUser } from '../../../api/src/lib/auth'
+
+export type InferredCurrentUser = Awaited<ReturnType<typeof getCurrentUser>>
+
+type UndefinedRoles = {
+  /**
+   * ⚠️ Heads-Up: This is undefined unless a roles key is returned from
+   * {@link getCurrentUser()}
+   *
+   * You may take a look at https://cedarjs.com/docs/tutorial/chapter7/rbac for
+   * a tutorial on how to add fully-fledged RBAC (Role-based Access Control) to
+   * your database model.
+   */
+  roles?: unknown | unknown[]
+}
+
+type Overwrite<T, U> = Omit<T, keyof U> & U
+
+declare module '@cedarjs/context' {
+  interface GlobalContext {
+    currentUser?: Overwrite<UndefinedRoles, InferredCurrentUser>
+  }
+}
+
+declare module '@cedarjs/auth' {
+  interface CurrentUser extends InferredCurrentUser {}
+}

package/dist/cjs/generate/templates/api-globImports.d.ts.template

@@ -0,0 +1,9 @@
+declare module 'src/services/**/*.{js,ts}'
+declare module 'src/directives/**/*.{js,ts}'
+declare module 'src/graphql/**/*.sdl.{js,ts}'
+declare module 'src/subscriptions/**/*.{js,ts}'
+
+
+declare module 'api/src/services/**/*.{js,ts}'
+declare module 'api/src/directives/**/*.{js,ts}'
+declare module 'api/src/graphql/**/*.sdl.{js,ts}'

package/dist/cjs/generate/templates/api-globalContext.d.ts.template

@@ -0,0 +1,7 @@
+import type { GlobalContext } from "@cedarjs/context"
+
+export {}
+
+declare global {
+  const context: GlobalContext
+}

package/dist/cjs/generate/templates/api-scenarios.d.ts.template

@@ -0,0 +1,10 @@
+import type { Scenario, DefineScenario, DescribeScenario } from '@cedarjs/testing/api'
+
+declare global {
+  /**
+   * Note that the scenario name must match the exports in your {model}.scenarios.ts file
+   */
+  const scenario: Scenario
+  const describeScenario: DescribeScenario
+  const defineScenario: DefineScenario
+}

package/dist/cjs/generate/templates/api-test-globals.d.ts.template

@@ -0,0 +1,5 @@
+import type { CurrentUser } from '@cedarjs/auth'
+
+declare global {
+  const mockCurrentUser: (currentUser: CurrentUser) => void
+}

package/dist/cjs/generate/templates/mirror-cell.d.ts.template

@@ -0,0 +1,13 @@
+import * as Cell from './${name}'
+import type { CellProps } from '@cedarjs/web'
+import type { ${queryResultType}, ${queryVariablesType} } from 'types/graphql'
+
+type SuccessType = typeof Cell.Success
+
+export * from './${name}'
+
+type CellInputs = CellProps<SuccessType, ${queryResultType}, typeof Cell, ${queryVariablesType}>
+
+export default function (props: CellInputs): ReturnType<SuccessType>
+
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/generate/templates/mirror-directoryNamedModule.d.ts.template

@@ -0,0 +1,5 @@
+import { default as DEFAULT } from './${name}'
+export default DEFAULT
+export * from './${name}'
+
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/generate/templates/web-routerRoutes.d.ts.template

@@ -0,0 +1,20 @@
+import { RouteParams, QueryParams } from '@cedarjs/router'
+
+declare module '@cedarjs/router' {
+  interface AvailableRoutes {
+    // Only "<Route />" components with a "name" and "path" prop will be populated here.
+${routes.map(
+  ({ props: { name, path }}) => {
+    return `    ${name}: (params?: RouteParams<"${path}"> & QueryParams) => "${path}"`
+  }
+).join('\n')}
+  }
+
+  export function useRoutePaths(): Record<keyof AvailableRoutes, string>
+  export function useRoutePath(routeName: keyof AvailableRoutes): string
+
+  /** Gets the name of the current route (as defined in your Routes file) */
+  export function useRouteName(): keyof AvailableRoutes | undefined
+}
+
+//# sourceMappingURL=web-routerRoutes.d.ts.map

package/dist/cjs/generate/templates/web-routesPages.d.ts.template

@@ -0,0 +1,13 @@
+${pages
+  .map(({ importName, importPath }) => {
+    return `import ${importName}Type from '${importPath}'`
+  })
+  .join('\n')}
+
+declare global {
+${pages.map(({ importName }) => {
+  return `  const ${importName}: typeof ${importName}Type`
+}).join('\n')}
+}
+
+//# sourceMappingURL=web-routesPages.d.ts.map

package/dist/cjs/generate/templates/web-test-globals.d.ts.template

@@ -0,0 +1,7 @@
+// Import other mocking function globals
+import '@cedarjs/testing'
+import { InferredCurrentUser } from './all-currentUser'
+
+declare global {
+  const mockCurrentUser: (currentUser: InferredCurrentUser) => void
+}

package/dist/cjs/generate/templates.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Write the contents of the template to the destination and interpolate the variables.
+ * The template is a string that uses standard es6 template literals which allow embded expression.
+ */
+export declare const writeTemplate: (templatePath: string, destination: string, templateValues?: Record<string, unknown>) => void;
+//# sourceMappingURL=templates.d.ts.map

package/dist/cjs/generate/templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../../../src/generate/templates.ts"],"names":[],"mappings":"AASA;;;GAGG;AACH,eAAO,MAAM,aAAa,iBACV,MAAM,eACP,MAAM,mBACH,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,SAYxC,CAAA"}

package/dist/cjs/generate/templates.js

@@ -0,0 +1,68 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var templates_exports = {};
+__export(templates_exports, {
+  writeTemplate: () => writeTemplate
+});
+module.exports = __toCommonJS(templates_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+const import_meta = {};
+const ___dirname = (
+  // __dirname will work for CJS, and import.meta.dirname will work for ESM
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  typeof __dirname !== "undefined" ? __dirname : import_meta?.dirname
+);
+const writeTemplate = (templatePath, destination, templateValues = {}) => {
+  const templateString = import_node_fs.default.readFileSync(
+    import_node_path.default.join(___dirname, templatePath),
+    "utf-8"
+  );
+  const template = templatized(templateString, templateValues);
+  import_node_fs.default.writeFileSync(
+    destination,
+    "// This file was generated by CedarJS\n" + template
+  );
+};
+const templatized = (template, vars = {}) => {
+  const handler = new Function(
+    "vars",
+    [
+      "const tagged = ( " + Object.keys(vars).join(", ") + " ) =>",
+      "`" + template + "`",
+      "return tagged(...Object.values(vars))"
+    ].join("\n")
+  );
+  return handler(vars);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  writeTemplate
+});

package/dist/cjs/generate/trustedDocuments.d.ts

@@ -0,0 +1,3 @@
+export declare const trustedDocumentsStore: (generatedFiles: any) => Promise<string>;
+export declare const replaceGqlTagWithTrustedDocumentGraphql: (generatedFiles: any) => Promise<void>;
+//# sourceMappingURL=trustedDocuments.d.ts.map

package/dist/cjs/generate/trustedDocuments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trustedDocuments.d.ts","sourceRoot":"","sources":["../../../src/generate/trustedDocuments.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,qBAAqB,mBAA0B,GAAG,oBA8B9D,CAAA;AAID,eAAO,MAAM,uCAAuC,mBAClC,GAAG,kBA8BpB,CAAA"}

package/dist/cjs/generate/trustedDocuments.js

@@ -0,0 +1,95 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var trustedDocuments_exports = {};
+__export(trustedDocuments_exports, {
+  replaceGqlTagWithTrustedDocumentGraphql: () => replaceGqlTagWithTrustedDocumentGraphql,
+  trustedDocumentsStore: () => trustedDocumentsStore
+});
+module.exports = __toCommonJS(trustedDocuments_exports);
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_prettier = require("prettier");
+var import_project_config = require("@cedarjs/project-config");
+const trustedDocumentsStore = async (generatedFiles) => {
+  let trustedDocumentsStoreFile = "";
+  const output = generatedFiles.filter(
+    (f) => f.filename.endsWith("persisted-documents.json")
+  );
+  const storeFile = output[0];
+  if (storeFile?.content) {
+    const content = await (0, import_prettier.format)(`export const store = ${storeFile.content}`, {
+      trailingComma: "es5",
+      bracketSpacing: true,
+      tabWidth: 2,
+      semi: false,
+      singleQuote: true,
+      arrowParens: "always",
+      parser: "typescript"
+    });
+    trustedDocumentsStoreFile = import_path.default.join(
+      (0, import_project_config.getPaths)().api.lib,
+      "trustedDocumentsStore.ts"
+    );
+    import_fs.default.mkdirSync(import_path.default.dirname(trustedDocumentsStoreFile), { recursive: true });
+    import_fs.default.writeFileSync(trustedDocumentsStoreFile, content);
+  }
+  return trustedDocumentsStoreFile;
+};
+const replaceGqlTagWithTrustedDocumentGraphql = async (generatedFiles) => {
+  const gqlFileOutput = generatedFiles.filter(
+    (f) => f.filename.endsWith("gql.ts")
+  );
+  const gqlFile = gqlFileOutput[0];
+  if (gqlFile?.content) {
+    gqlFile.content += `
+
+      export function gql(source: string | TemplateStringsArray) {
+        if (typeof source === 'string') {
+          return graphql(source)
+        }
+
+        return graphql(source.join('\\n'))
+      }`;
+    const content = await (0, import_prettier.format)(gqlFile.content, {
+      trailingComma: "es5",
+      bracketSpacing: true,
+      tabWidth: 2,
+      semi: true,
+      singleQuote: false,
+      arrowParens: "always",
+      parser: "typescript"
+    });
+    import_fs.default.writeFileSync(gqlFile.filename, content);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  replaceGqlTagWithTrustedDocumentGraphql,
+  trustedDocumentsStore
+});

package/dist/cjs/generate/typeDefinitions.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Generate all the types for a CedarJS project and return the generated path to
+ * files, so they're logged
+ */
+export declare const generateTypeDefs: () => Promise<{
+    typeDefFiles: string[];
+    errors: {
+        message: string;
+        error: unknown;
+    }[];
+}>;
+export declare const generateMirrorDirectoryNamedModules: () => string[];
+export declare const mirrorPathForDirectoryNamedModules: (p: string, rwjsPaths?: import("@cedarjs/project-config").Paths) => string[];
+export declare const generateMirrorDirectoryNamedModule: (p: string, rwjsPaths?: import("@cedarjs/project-config").Paths) => string;
+export declare const generateMirrorCells: () => string[];
+export declare const mirrorPathForCell: (p: string, rwjsPaths?: import("@cedarjs/project-config").Paths) => string[];
+export declare const generateMirrorCell: (p: string, rwjsPaths?: import("@cedarjs/project-config").Paths) => string;
+export declare const generateTypeDefRouterRoutes: () => string[];
+export declare const generateTypeDefRouterPages: () => string[];
+export declare const generateTypeDefCurrentUser: () => string[];
+export declare const generateTypeDefScenarios: () => string[];
+export declare const generateTypeDefTestMocks: () => string[];
+export declare const generateTypeDefGlobImports: () => string[];
+export declare const generateTypeDefGlobalContext: () => string[];
+/**
+ * Typescript does not preserve triple slash directives when outputting js or d.ts files.
+ * This is a work around so that *.svg, *.png, etc. imports have types.
+ */
+export declare const generateViteClientTypesDirective: () => string[];
+//# sourceMappingURL=typeDefinitions.d.ts.map

package/dist/cjs/generate/typeDefinitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeDefinitions.d.ts","sourceRoot":"","sources":["../../../src/generate/typeDefinitions.ts"],"names":[],"mappings":"AAyCA;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;EAyB5B,CAAA;AAED,eAAO,MAAM,mCAAmC,gBAK/C,CAAA;AAED,eAAO,MAAM,kCAAkC,MAC1C,MAAM,kEAUV,CAAA;AAED,eAAO,MAAM,kCAAkC,MAC1C,MAAM,gEAqDV,CAAA;AAED,eAAO,MAAM,mBAAmB,gBAG/B,CAAA;AAED,eAAO,MAAM,iBAAiB,MAAO,MAAM,kEAQ1C,CAAA;AAED,eAAO,MAAM,kBAAkB,MAAO,MAAM,gEA8D3C,CAAA;AAiBD,eAAO,MAAM,2BAA2B,gBAmEvC,CAAA;AAED,eAAO,MAAM,0BAA0B,gBA8CtC,CAAA;AAED,eAAO,MAAM,0BAA0B,gBAEtC,CAAA;AAED,eAAO,MAAM,wBAAwB,gBAEpC,CAAA;AAED,eAAO,MAAM,wBAAwB,gBAKpC,CAAA;AAED,eAAO,MAAM,0BAA0B,gBAEtC,CAAA;AAED,eAAO,MAAM,4BAA4B,gBAExC,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,gCAAgC,gBAW5C,CAAA"}