@cedarjs/vite 5.0.6 → 5.0.7-next.219

package/dist/plugins/vite-plugin-cedar-gqlorm-inject.d.ts

@@ -0,0 +1,29 @@
+import type { Plugin } from 'vite';
+/**
+ * Vite plugin that injects the auto-generated gqlorm backend into
+ * `api/src/functions/graphql.ts` at build time.
+ *
+ * When `experimental.gqlorm.enabled = true` and `.cedar/gqlorm/backend.ts`
+ * exists, this plugin:
+ *
+ * 1. Adds imports at the top of graphql.ts:
+ *      import * as __gqlorm_sdl__ from '../../../.cedar/gqlorm/backend'
+ *      import { db as __gqlorm_db__ } from 'src/lib/db'
+ *
+ * 2. Inserts a statement immediately before the `createGraphQLHandler` call:
+ *      Object.assign(sdls, {
+ *        __gqlorm__: {
+ *          schema: __gqlorm_sdl__.schema,
+ *          resolvers: __gqlorm_sdl__.createGqlormResolvers(__gqlorm_db__),
+ *        },
+ *      })
+ *
+ * The `sdls` variable is already a `let` binding because
+ * `vite-plugin-cedar-import-dir` transforms the glob import
+ * `import sdls from 'src/graphql/**\/*.sdl.{js,ts}'` into `let sdls = {}`.
+ *
+ * This plugin is a no-op when gqlorm is disabled or the backend file does
+ * not exist.
+ */
+export declare function cedarGqlormInjectPlugin(): Plugin;
+//# sourceMappingURL=vite-plugin-cedar-gqlorm-inject.d.ts.map

package/dist/plugins/vite-plugin-cedar-gqlorm-inject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plugin-cedar-gqlorm-inject.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-cedar-gqlorm-inject.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAQlC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,CAgHhD"}

package/dist/plugins/vite-plugin-cedar-gqlorm-inject.js

@@ -0,0 +1,76 @@
+import fs from "node:fs";
+import path from "node:path";
+import {
+  getConfig,
+  getPaths,
+  importStatementPath
+} from "@cedarjs/project-config";
+function cedarGqlormInjectPlugin() {
+  return {
+    name: "cedar-gqlorm-inject",
+    transform(code, id) {
+      if (!id.endsWith("/graphql.ts") && !id.endsWith("/graphql.js")) {
+        return null;
+      }
+      if (code.includes("__gqlorm_sdl__")) {
+        return null;
+      }
+      if (!code.includes("createGraphQLHandler")) {
+        return null;
+      }
+      let config;
+      try {
+        config = getConfig();
+      } catch {
+        return null;
+      }
+      if (!config.experimental?.gqlorm?.enabled) {
+        return null;
+      }
+      let paths;
+      try {
+        paths = getPaths();
+      } catch {
+        return null;
+      }
+      const backendPathWithoutExt = path.join(
+        paths.generated.base,
+        "gqlorm",
+        "backend"
+      );
+      if (!fs.existsSync(backendPathWithoutExt + ".ts")) {
+        return null;
+      }
+      const handlerPattern = /^export\s+const\s+(\w+)\s*=\s*createGraphQLHandler\s*\(/m;
+      const handlerMatch = handlerPattern.exec(code);
+      if (!handlerMatch) {
+        return null;
+      }
+      const handlerLineStart = code.lastIndexOf("\n", handlerMatch.index) + 1;
+      const relPath = importStatementPath(
+        path.relative(path.dirname(id), backendPathWithoutExt)
+      ) + ".ts";
+      const dbSrcPath = path.join(paths.api.src, "lib", "db");
+      const relDbPath = importStatementPath(path.relative(path.dirname(id), dbSrcPath)) + ".ts";
+      const importDb = `import { db as __gqlorm_db__ } from '${relDbPath}'`;
+      const importSdl = `import * as __gqlorm_sdl__ from '${relPath}'`;
+      const importsToAdd = `${importDb}
+${importSdl}
+`;
+      const sdlsMutation = `Object.assign(sdls, {
+    __gqlorm__: {
+      schema: __gqlorm_sdl__.schema,
+      resolvers: __gqlorm_sdl__.createGqlormResolvers(__gqlorm_db__),
+    },
+  })
+  `;
+      const transformed = importsToAdd + code.slice(0, handlerLineStart) + sdlsMutation + code.slice(handlerLineStart);
+      return {
+        code: transformed
+      };
+    }
+  };
+}
+export {
+  cedarGqlormInjectPlugin
+};

package/dist/plugins/vite-plugin-cedar-graphql-options-extract.d.ts

@@ -0,0 +1,42 @@
+import type { SourceMap } from 'magic-string';
+import type { Plugin } from 'vite';
+/**
+ * Vite plugin that extracts options passed to createGraphQLHandler into an
+ * exported variable.
+ *
+ * Transforms:
+ *   export const handler = createGraphQLHandler({ options })
+ * into:
+ *   export const __cedar_graphqlOptions = { options }
+ *   export const handler = createGraphQLHandler(__cedar_graphqlOptions)
+ *
+ * This allows options to be imported elsewhere and enables the gqlorm-inject
+ * plugin to mutate the sdls object in-place before the call.
+ *
+ * The extraction uses an oxc-parser AST walk (see `applyGraphqlOptionsExtract`
+ * below) so the transform is robust against aliased imports, nested calls, and
+ * string escapes. The same logic is duplicated in
+ * `@cedarjs/internal` (`applyGraphqlOptionsExtract`) for the standalone esbuild
+ * API build
+ */
+export declare function cedarGraphqlOptionsExtractPlugin(): Plugin;
+/**
+ * Extracts the options argument from createGraphQLHandler calls and stores
+ * them in an exported variable. Returns the transformed code with a sourcemap,
+ * or null if no transformation was needed.
+ *
+ * Transforms:
+ *   export const handler = createGraphQLHandler({ options })
+ * into:
+ *   export const __cedar_graphqlOptions = { options }
+ *   export const handler = createGraphQLHandler(__cedar_graphqlOptions)
+ *
+ * Duplicate of `@cedarjs/internal`'s `applyGraphqlOptionsExtract` so this
+ * logic can run inside the Vite plugin pipeline without depending on internal's
+ * build output.
+ */
+export declare function applyGraphqlOptionsExtract(code: string): {
+    code: string;
+    map: SourceMap;
+} | null;
+//# sourceMappingURL=vite-plugin-cedar-graphql-options-extract.d.ts.map

package/dist/plugins/vite-plugin-cedar-graphql-options-extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plugin-cedar-graphql-options-extract.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-cedar-graphql-options-extract.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAG7C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAElC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gCAAgC,IAAI,MAAM,CA2BzD;AAQD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,MAAM,GACX;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,SAAS,CAAA;CAAE,GAAG,IAAI,CAiHzC"}

package/dist/plugins/vite-plugin-cedar-graphql-options-extract.js

@@ -0,0 +1,103 @@
+import MagicString from "magic-string";
+import { parseSync, Visitor } from "oxc-parser";
+function cedarGraphqlOptionsExtractPlugin() {
+  return {
+    name: "cedar-graphql-options-extract",
+    transform(code, id) {
+      if (!id.endsWith("/graphql.ts") && !id.endsWith("/graphql.js")) {
+        return null;
+      }
+      if (!code.includes("createGraphQLHandler")) {
+        return null;
+      }
+      const result = applyGraphqlOptionsExtract(code);
+      if (!result) {
+        return null;
+      }
+      return {
+        code: result.code,
+        map: result.map
+      };
+    }
+  };
+}
+const GRAPHQL_OPTIONS_ERROR_PREFIX = "Could not read the GraphQL options in api/src/functions/graphql. Cedar needs to statically extract them so the api server can serve /graphql and its health endpoint. ";
+const GRAPHQL_OPTIONS_ERROR_SUFFIX = " Expected a single `createGraphQLHandler({ ... })` call with the options passed directly as an object, an identifier, a call, or a ternary.";
+function applyGraphqlOptionsExtract(code) {
+  if (code.includes("__cedar_graphqlOptions")) {
+    return null;
+  }
+  const { program } = parseSync("graphql.ts", code, {
+    // lang is only a parse hint; 'ts' also parses JS (the graphql handler can
+    // be graphql.js in JS projects), so this is safe for both file types.
+    lang: "ts",
+    sourceType: "module"
+  });
+  const importNames = /* @__PURE__ */ new Set();
+  for (const node of program.body) {
+    if (node.type === "ImportDeclaration") {
+      if (node.source.value !== "@cedarjs/graphql-server") {
+        continue;
+      }
+      for (const specifier of node.specifiers) {
+        if (specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "createGraphQLHandler") {
+          importNames.add(specifier.local.name);
+        }
+      }
+    }
+  }
+  if (importNames.size === 0) {
+    return null;
+  }
+  const callExpressionPaths = [];
+  new Visitor({
+    CallExpression(node) {
+      if (node.callee.type === "Identifier" && importNames.has(node.callee.name)) {
+        callExpressionPaths.push(node);
+      }
+    }
+  }).visit(program);
+  if (callExpressionPaths.length > 1) {
+    throw new Error(
+      GRAPHQL_OPTIONS_ERROR_PREFIX + "Found more than one call to createGraphQLHandler." + GRAPHQL_OPTIONS_ERROR_SUFFIX
+    );
+  }
+  const callExpression = callExpressionPaths[0];
+  if (!callExpression) {
+    throw new Error(
+      GRAPHQL_OPTIONS_ERROR_PREFIX + "createGraphQLHandler is imported but never called." + GRAPHQL_OPTIONS_ERROR_SUFFIX
+    );
+  }
+  const options = callExpression.arguments[0];
+  if (!options) {
+    throw new Error(
+      GRAPHQL_OPTIONS_ERROR_PREFIX + "createGraphQLHandler was called without any options." + GRAPHQL_OPTIONS_ERROR_SUFFIX
+    );
+  }
+  if (options.type !== "Identifier" && options.type !== "ObjectExpression" && options.type !== "CallExpression" && options.type !== "ConditionalExpression") {
+    throw new Error(
+      GRAPHQL_OPTIONS_ERROR_PREFIX + `The options argument is a ${options.type}, which can't be read statically.` + GRAPHQL_OPTIONS_ERROR_SUFFIX
+    );
+  }
+  const optionsStart = options.start;
+  const optionsEnd = options.end;
+  const lineStart = code.lastIndexOf("\n", callExpression.start) + 1;
+  const indentMatch = /^[ \t]*/.exec(code.slice(lineStart));
+  const indent = indentMatch ? indentMatch[0] : "";
+  const optionsConst = `${indent}export const __cedar_graphqlOptions = ${code.slice(
+    optionsStart,
+    optionsEnd
+  )}
+`;
+  const s = new MagicString(code);
+  s.prependLeft(lineStart, optionsConst);
+  s.overwrite(optionsStart, optionsEnd, "__cedar_graphqlOptions");
+  return {
+    code: s.toString(),
+    map: s.generateMap({ hires: true })
+  };
+}
+export {
+  applyGraphqlOptionsExtract,
+  cedarGraphqlOptionsExtractPlugin
+};

package/dist/plugins/vite-plugin-cedar-import-dir.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vite-plugin-cedar-import-dir.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-cedar-import-dir.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAIlC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAgH7C"}
+{"version":3,"file":"vite-plugin-cedar-import-dir.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-cedar-import-dir.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAIlC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CA4H7C"}

package/dist/plugins/vite-plugin-cedar-import-dir.js

@@ -1,6 +1,8 @@
+import fs from "node:fs";
 import path from "node:path";
-import { parse, Lang } from "@ast-grep/napi";
-import fg from "fast-glob";
+import MagicString from "magic-string";
+import { parseSync } from "oxc-parser";
+import { normalizePath } from "vite";
 import { importStatementPath, getPaths } from "@cedarjs/project-config";
 function cedarImportDirPlugin() {
   return {
@@ -10,51 +12,64 @@ function cedarImportDirPlugin() {
       if (!code.includes("/**/")) {
         return null;
       }
-      const ext = path.extname(id);
-      const language = ext === ".ts" || ext === ".tsx" ? Lang.TypeScript : Lang.JavaScript;
-      let ast;
+      let program;
       try {
-        ast = parse(language, code);
+        program = parseSync(id, code).program;
       } catch (error) {
         console.warn("Failed to parse file:", id);
         console.warn(error);
         return null;
       }
-      const root = ast.root();
       let hasTransformations = false;
-      const edits = [];
-      const globImports = root.findAll({
-        rule: {
-          pattern: "import $DEFAULT_IMPORT from $SOURCE"
+      const s = new MagicString(code);
+      for (const node of program.body) {
+        if (node.type !== "ImportDeclaration") {
+          continue;
         }
-      });
-      for (const importNode of globImports) {
-        const sourceNode = importNode.getMatch("SOURCE");
-        const defaultImportNode = importNode.getMatch("DEFAULT_IMPORT");
-        if (!sourceNode || !defaultImportNode) {
+        const defaultSpecifier = node.specifiers.find(
+          (specifier) => specifier.type === "ImportDefaultSpecifier"
+        );
+        if (!defaultSpecifier) {
           continue;
         }
-        const sourceValue = sourceNode.text().slice(1, -1);
+        const sourceValue = node.source.value;
         if (!sourceValue.includes("/**/")) {
           continue;
         }
         hasTransformations = true;
-        const importName = defaultImportNode.text();
+        const importName = defaultSpecifier.local.name;
         const importGlob = importStatementPath(sourceValue);
-        const cwd = importGlob.startsWith("src/") ? getPaths().api.base : path.dirname(id);
+        let cwd = path.dirname(id);
+        if (importGlob.startsWith("src/")) {
+          const normalizedId = normalizePath(id);
+          const apiBase = normalizePath(getPaths().api.base);
+          const webBase = normalizePath(getPaths().web.base);
+          if (normalizedId.startsWith(apiBase)) {
+            cwd = getPaths().api.base;
+          } else if (normalizedId.startsWith(webBase)) {
+            cwd = getPaths().web.base;
+          } else {
+            throw new Error(`Unexpected file location: ${id}`);
+          }
+        }
         try {
-          const dirFiles = fg.sync(importGlob, { cwd }).filter(
-            (n) => !n.includes(".test.") && !n.includes(".scenarios.") && !n.includes(".d.ts")
-          );
+          const dirFiles = fs.globSync(importGlob, {
+            cwd,
+            exclude: (n) => n.includes(".test.") || n.includes(".scenarios.") || n.includes(".d.ts")
+          });
           const staticGlob = importGlob.split("*")[0];
           const filePathToVarName = (filePath) => {
-            return filePath.replace(staticGlob, "").replace(/\.(js|ts)$/, "").replace(/[^a-zA-Z0-9]/g, "_");
+            const normalizedPath = normalizePath(filePath);
+            return normalizedPath.replace(staticGlob, "").replace(/\.(js|ts)$/, "").replace(/[^a-zA-Z0-9]/g, "_");
           };
           let replacement = `let ${importName} = {};
 `;
           for (const filePath of dirFiles) {
-            const { dir: fileDir, name: fileName } = path.parse(filePath);
-            const fileImportPath = fileDir + "/" + fileName;
+            const normalizedPath = normalizePath(filePath);
+            const lastSlash = normalizedPath.lastIndexOf("/");
+            const fileDir = lastSlash >= 0 ? normalizedPath.slice(0, lastSlash) : "";
+            const fileName = normalizedPath.slice(lastSlash + 1).replace(/\.\w+$/, "");
+            const fileImportPath = fileDir ? fileDir + "/" + fileName : fileName;
             const filePathVarName = filePathToVarName(filePath);
             const namespaceImportName = `${importName}_${filePathVarName}`;
             replacement += `import * as ${namespaceImportName} from '${fileImportPath}';
@@ -62,17 +77,15 @@ function cedarImportDirPlugin() {
             replacement += `${importName}.${filePathVarName} = ${namespaceImportName};
 `;
           }
-          edits.push(importNode.replace(replacement.trim()));
+          s.overwrite(node.start, node.end, replacement.trim());
         } catch (error) {
           console.warn(`Failed to process glob import: ${sourceValue}`, error);
         }
       }
-      if (hasTransformations && edits.length > 0) {
-        const transformedCode = root.commitEdits(edits);
+      if (hasTransformations) {
         return {
-          code: transformedCode,
-          map: null
-          // For simplicity, not generating source maps
+          code: s.toString(),
+          map: s.generateMap({ hires: true })
         };
       }
       return null;

package/dist/plugins/vite-plugin-cedar-log-formatter-dev.d.ts

@@ -0,0 +1,28 @@
+import type { Plugin } from 'vite';
+import type * as apiLogger from '@cedarjs/api/logger';
+/**
+ * Dev-only Vite plugin that makes the api's pino logger pretty-print
+ * through the same formatter plain `yarn cedar dev` gets via its
+ * `... | cedar-log-formatter` shell pipe.
+ *
+ * `--ud` mode runs the api in-process as Vite SSR middleware, so there's no
+ * separate api process whose stdout a shell pipe could format externally,
+ * and pino's default destination writes straight to file descriptor 1
+ * (bypassing `process.stdout.write`), so patching stdout wouldn't see the
+ * log lines either. Instead, this intercepts resolution of
+ * `@cedarjs/api/logger` and swaps in a wrapped `createLogger` that injects
+ * a formatting `destination` whenever the caller (the app's own
+ * `api/src/lib/logger.ts`) doesn't already supply one.
+ *
+ * Only registered in `createApiViteServer()`'s dev-only Vite instance —
+ * never touched by any production build path — so this has no effect on
+ * (and no dependency footprint added to) a deployed api.
+ */
+export declare function cedarApiLogFormatterDevPlugin(): Plugin;
+export declare function createFormattingDestination(): {
+    write(chunk: string): void;
+};
+type CreateLoggerParams = Parameters<typeof apiLogger.createLogger>[0];
+export declare function createLogger(params?: CreateLoggerParams): apiLogger.Logger;
+export {};
+//# sourceMappingURL=vite-plugin-cedar-log-formatter-dev.d.ts.map

package/dist/plugins/vite-plugin-cedar-log-formatter-dev.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plugin-cedar-log-formatter-dev.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-cedar-log-formatter-dev.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAMlC,OAAO,KAAK,KAAK,SAAS,MAAM,qBAAqB,CAAA;AAOrD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,6BAA6B,IAAI,MAAM,CAoCtD;AAED,wBAAgB,2BAA2B;iBAK1B,MAAM;EAYtB;AAED,KAAK,kBAAkB,GAAG,UAAU,CAAC,OAAO,SAAS,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAA;AAUtE,wBAAgB,YAAY,CAAC,MAAM,GAAE,kBAAuB,oBAS3D"}

package/dist/plugins/vite-plugin-cedar-log-formatter-dev.js

@@ -0,0 +1,67 @@
+import { LogFormatter } from "@cedarjs/api-server/logFormatter";
+const INTERCEPTED_SPECIFIER = "@cedarjs/api/logger";
+const VIRTUAL_MODULE_ID = "virtual:cedar-api-logger-dev";
+const RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
+function cedarApiLogFormatterDevPlugin() {
+  return {
+    name: "cedar-api-log-formatter-dev",
+    enforce: "pre",
+    resolveId(id, importer) {
+      if (id === INTERCEPTED_SPECIFIER && importer !== RESOLVED_VIRTUAL_MODULE_ID) {
+        return RESOLVED_VIRTUAL_MODULE_ID;
+      }
+      return null;
+    },
+    load(id) {
+      if (id !== RESOLVED_VIRTUAL_MODULE_ID) {
+        return null;
+      }
+      return `
+        import * as realLogger from ${JSON.stringify(INTERCEPTED_SPECIFIER)}
+        import { LogFormatter } from '@cedarjs/api-server/logFormatter'
+
+        export * from ${JSON.stringify(INTERCEPTED_SPECIFIER)}
+
+        ${createFormattingDestination.toString()}
+
+        // toString() doesn't include the 'export' keyword
+        export ${createLogger.toString()}
+        `;
+    }
+  };
+}
+function createFormattingDestination() {
+  const format = LogFormatter();
+  let buffered = "";
+  return {
+    write(chunk) {
+      buffered += chunk;
+      const lines = buffered.split("\n");
+      buffered = lines.pop() ?? "";
+      for (const line of lines) {
+        if (line.length > 0) {
+          process.stdout.write(format(line));
+        }
+      }
+    }
+  };
+}
+const realLogger = {
+  createLogger: (_params) => {
+    return {};
+  }
+};
+function createLogger(params = {}) {
+  if (params.destination) {
+    return realLogger.createLogger(params);
+  }
+  return realLogger.createLogger({
+    ...params,
+    destination: createFormattingDestination()
+  });
+}
+export {
+  cedarApiLogFormatterDevPlugin,
+  createFormattingDestination,
+  createLogger
+};

package/dist/plugins/vite-plugin-cedar-mock-cell-data.d.ts

@@ -0,0 +1,28 @@
+import type { Plugin } from 'vite';
+/**
+ * Vite plugin that automatically wraps the `standard` export in Cell mock files
+ * with `mockGraphQLQuery`.
+ *
+ * Only active in non-production environments (for Storybook and Jest).
+ *
+ * Transforms `*.Cell.mock.[js,ts]` files by:
+ * 1. Determining the query operation name from the adjacent Cell's QUERY export
+ * 2. Wrapping the `standard` function export in `mockGraphQLQuery(operationName, fn)`
+ * 3. If the Cell has an `afterQuery` export, also wraps with `afterQuery(fn())`
+ *
+ * This is a 1:1 port of `babel-plugin-redwood-mock-cell-data`.
+ */
+export declare function cedarMockCellDataPlugin(): Plugin;
+export declare const getCellMetadata: (p: string) => {
+    hasDefaultExport: boolean;
+    namedExports: NamedExports[];
+    hasQueryExport: NamedExports | undefined;
+    hasAfterQueryExport: NamedExports | undefined;
+    operationName: string;
+};
+interface NamedExports {
+    name: string;
+    type: 're-export' | 'variable' | 'function' | 'class';
+}
+export {};
+//# sourceMappingURL=vite-plugin-cedar-mock-cell-data.d.ts.map

package/dist/plugins/vite-plugin-cedar-mock-cell-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plugin-cedar-mock-cell-data.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-cedar-mock-cell-data.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAMlC;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,CA2KhD;AAcD,eAAO,MAAM,eAAe,GAAI,GAAG,MAAM;;;;;;CAoFxC,CAAA;AAgCD,UAAU,YAAY;IACpB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,UAAU,GAAG,OAAO,CAAA;CACtD"}