diff --git a/packages/builder/vite.config.mjs.timestamp-1728399274731-fb0dcfaf9cacc.mjs b/packages/builder/vite.config.mjs.timestamp-1728399274731-fb0dcfaf9cacc.mjs new file mode 100644 index 0000000000..8a28a7ca60 --- /dev/null +++ b/packages/builder/vite.config.mjs.timestamp-1728399274731-fb0dcfaf9cacc.mjs @@ -0,0 +1,146 @@ +// vite.config.mjs +import { svelte } from "file:///Users/aptk/dev/budibase/node_modules/@sveltejs/vite-plugin-svelte/dist/index.js"; +import replace from "file:///Users/aptk/dev/budibase/node_modules/@rollup/plugin-replace/dist/es/index.js"; +import { defineConfig, loadEnv } from "file:///Users/aptk/dev/budibase/node_modules/vite/dist/node/index.js"; +import { viteStaticCopy } from "file:///Users/aptk/dev/budibase/node_modules/vite-plugin-static-copy/dist/index.js"; +import path from "path"; +var ignoredWarnings = [ + "unused-export-let", + "css-unused-selector", + "module-script-reactive-declaration", + "a11y-no-onchange", + "a11y-click-events-have-key-events" +]; +var copyFonts = (dest) => viteStaticCopy({ + targets: [ + { + src: "../../node_modules/@fontsource/source-sans-pro", + dest + }, + { + src: "../../node_modules/remixicon/fonts/*", + dest + } + ] +}); +var vite_config_default = defineConfig(({ mode }) => { + const isProduction = mode === "production"; + const env = loadEnv(mode, process.cwd()); + const devOnlyPlugins = [ + // Copy fonts to an additional path so that svelte's automatic + // prefixing of the base URL path can still resolve assets + copyFonts("builder/fonts") + ]; + return { + test: { + setupFiles: ["./vitest.setup.js"], + globals: true, + environment: "jsdom" + }, + server: { + fs: { + strict: false + }, + hmr: { + protocol: env.VITE_HMR_PROTOCOL || "ws", + clientPort: env.VITE_HMR_CLIENT_PORT || 3e3, + path: env.VITE_HMR_PATH || "/" + }, + port: 3e3 + }, + base: "/builder/", + build: { + minify: isProduction, + outDir: "../server/builder", + sourcemap: !isProduction + }, + plugins: [ + svelte({ + hot: !isProduction, + emitCss: true, + onwarn: (warning, handler) => { + if (!ignoredWarnings.includes(warning.code)) { + handler(warning); + } + } + }), + replace({ + preventAssignment: true, + "process.env.NODE_ENV": JSON.stringify( + isProduction ? "production" : "development" + ), + "process.env.POSTHOG_TOKEN": JSON.stringify(process.env.POSTHOG_TOKEN) + }), + copyFonts("fonts"), + ...isProduction ? [] : devOnlyPlugins + ], + optimizeDeps: { + exclude: ["@roxi/routify", "fsevents"] + }, + resolve: { + dedupe: ["@roxi/routify"], + alias: [ + { + find: "assets", + replacement: path.resolve("./assets") + }, + { + find: "components", + replacement: path.resolve("./src/components") + }, + { + find: "pages", + replacement: path.resolve("./src/pages") + }, + { + find: "templates", + replacement: path.resolve("./src/templates") + }, + { + find: "stores", + replacement: path.resolve("./src/stores") + }, + { + find: "dataBinding", + replacement: path.resolve("./src/dataBinding.js") + }, + { + find: "api", + replacement: path.resolve("./src/api.js") + }, + { + find: "constants", + replacement: path.resolve("./src/constants") + }, + { + find: "analytics", + replacement: path.resolve("./src/analytics") + }, + { + find: "actions", + replacement: path.resolve("./src/actions") + }, + { + find: "helpers", + replacement: path.resolve("./src/helpers") + }, + { + find: "@budibase/types", + replacement: path.resolve("../types/src") + }, + { + find: "@budibase/shared-core", + replacement: path.resolve("../shared-core/src") + }, + { + find: "@budibase/bbui", + replacement: path.resolve("../bbui/src") + } + ] + } + }; +}); +export { + vite_config_default as default +}; +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["vite.config.mjs"],
  "sourcesContent": ["const __vite_injected_original_dirname = \"/Users/aptk/dev/budibase/packages/builder\";const __vite_injected_original_filename = \"/Users/aptk/dev/budibase/packages/builder/vite.config.mjs\";const __vite_injected_original_import_meta_url = \"file:///Users/aptk/dev/budibase/packages/builder/vite.config.mjs\";import { svelte } from \"@sveltejs/vite-plugin-svelte\"\nimport replace from \"@rollup/plugin-replace\"\nimport { defineConfig, loadEnv } from \"vite\"\nimport { viteStaticCopy } from \"vite-plugin-static-copy\"\nimport path from \"path\"\n\nconst ignoredWarnings = [\n  \"unused-export-let\",\n  \"css-unused-selector\",\n  \"module-script-reactive-declaration\",\n  \"a11y-no-onchange\",\n  \"a11y-click-events-have-key-events\",\n]\n\nconst copyFonts = dest =>\n  viteStaticCopy({\n    targets: [\n      {\n        src: \"../../node_modules/@fontsource/source-sans-pro\",\n        dest,\n      },\n      {\n        src: \"../../node_modules/remixicon/fonts/*\",\n        dest,\n      },\n    ],\n  })\n\nexport default defineConfig(({ mode }) => {\n  const isProduction = mode === \"production\"\n  const env = loadEnv(mode, process.cwd())\n\n  // Plugins to only run in dev\n  const devOnlyPlugins = [\n    // Copy fonts to an additional path so that svelte's automatic\n    // prefixing of the base URL path can still resolve assets\n    copyFonts(\"builder/fonts\"),\n]\n\n  return {\n    test: {\n      setupFiles: [\"./vitest.setup.js\"],\n      globals: true,\n      environment: \"jsdom\",\n    },\n    server: {\n      fs: {\n        strict: false,\n      },\n      hmr: {\n        protocol: env.VITE_HMR_PROTOCOL || \"ws\",\n        clientPort: env.VITE_HMR_CLIENT_PORT || 3000,\n        path: env.VITE_HMR_PATH || \"/\",\n      },\n      port: 3000,\n    },\n    base: \"/builder/\",\n    build: {\n      minify: isProduction,\n      outDir: \"../server/builder\",\n      sourcemap: !isProduction,\n    },\n    plugins: [\n      svelte({\n        hot: !isProduction,\n        emitCss: true,\n        onwarn: (warning, handler) => {\n          // Ignore some warnings\n          if (!ignoredWarnings.includes(warning.code)) {\n            handler(warning)\n          }\n        },\n      }),\n      replace({\n        preventAssignment: true,\n        \"process.env.NODE_ENV\": JSON.stringify(\n          isProduction ? \"production\" : \"development\"\n        ),\n        \"process.env.POSTHOG_TOKEN\": JSON.stringify(process.env.POSTHOG_TOKEN),\n      }),\n      copyFonts(\"fonts\"),\n      ...(isProduction ? [] : devOnlyPlugins),\n    ],\n    optimizeDeps: {\n      exclude: [\"@roxi/routify\", \"fsevents\"],\n    },\n    resolve: {\n      dedupe: [\"@roxi/routify\"],\n      alias: [\n        {\n          find: \"assets\",\n          replacement: path.resolve(\"./assets\"),\n        },\n        {\n          find: \"components\",\n          replacement: path.resolve(\"./src/components\"),\n        },\n        {\n          find: \"pages\",\n          replacement: path.resolve(\"./src/pages\"),\n        },\n        {\n          find: \"templates\",\n          replacement: path.resolve(\"./src/templates\"),\n        },\n        {\n          find: \"stores\",\n          replacement: path.resolve(\"./src/stores\"),\n        },\n        {\n          find: \"dataBinding\",\n          replacement: path.resolve(\"./src/dataBinding.js\"),\n        },\n        {\n          find: \"api\",\n          replacement: path.resolve(\"./src/api.js\"),\n        },\n        {\n          find: \"constants\",\n          replacement: path.resolve(\"./src/constants\"),\n        },\n        {\n          find: \"analytics\",\n          replacement: path.resolve(\"./src/analytics\"),\n        },\n        {\n          find: \"actions\",\n          replacement: path.resolve(\"./src/actions\"),\n        },\n        {\n          find: \"helpers\",\n          replacement: path.resolve(\"./src/helpers\"),\n        },\n        {\n          find: \"@budibase/types\",\n          replacement: path.resolve(\"../types/src\"),\n        },\n        {\n          find: \"@budibase/shared-core\",\n          replacement: path.resolve(\"../shared-core/src\"),\n        },\n        {\n          find: \"@budibase/bbui\",\n          replacement: path.resolve(\"../bbui/src\"),\n        },\n      ],\n    },\n  }\n})\n"],
  "mappings": "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",
  "names": []
}
 diff --git a/packages/frontend-core/src/components/grid/stores/config.js b/packages/frontend-core/src/components/grid/stores/config.js index d0cda1e114..d4ef44545b 100644 --- a/packages/frontend-core/src/components/grid/stores/config.js +++ b/packages/frontend-core/src/components/grid/stores/config.js @@ -43,6 +43,14 @@ export const deriveStores = context => { // Disable some features if we're editing a view if (type === "viewV2") { config.canEditColumns = false + + // Disable features for calculation views + if ($definition?.type === ViewV2Type.CALCULATION) { + config.canAddRows = false + config.canEditRows = false + config.canDeleteRows = false + config.canExpandRows = false + } } // Disable adding rows if we don't have any valid columns @@ -60,19 +68,7 @@ export const deriveStores = context => { config.canEditColumns = false } - // Disable features for calculation views - if (type === "viewV2" && $definition?.type === ViewV2Type.CALCULATION) { - config.canAddRows = false - config.canEditRows = false - config.canDeleteRows = false - config.canExpandRows = false - } - return config } ) - - return { - config, - } } diff --git a/packages/frontend-core/src/components/grid/stores/datasource.js b/packages/frontend-core/src/components/grid/stores/datasource.js index 869cd56730..6aa607f7ed 100644 --- a/packages/frontend-core/src/components/grid/stores/datasource.js +++ b/packages/frontend-core/src/components/grid/stores/datasource.js @@ -2,6 +2,7 @@ import { derived, get } from "svelte/store" import { getDatasourceDefinition, getDatasourceSchema } from "../../../fetch" import { enrichSchemaWithRelColumns, memo } from "../../../utils" import { cloneDeep } from "lodash" +import { ViewV2Type } from "@budibase/types" export const createStores = () => { const definition = memo(null) @@ -81,13 +82,20 @@ export const deriveStores = context => { } ) - const hasBudibaseIdentifiers = derived(datasource, $datasource => { - let type = $datasource?.type - if (type === "provider") { - type = $datasource.value?.datasource?.type + const hasBudibaseIdentifiers = derived( + [datasource, definition], + ([$datasource, $definition]) => { + let type = $datasource?.type + if (type === "provider") { + type = $datasource.value?.datasource?.type + } + // Handle calculation views + if (type === "viewV2" && $definition?.type === ViewV2Type.CALCULATION) { + return false + } + return ["table", "viewV2", "link"].includes(type) } - return ["table", "viewV2", "link"].includes(type) - }) + ) return { schema, diff --git a/packages/frontend-core/src/fetch/ViewV2Fetch.js b/packages/frontend-core/src/fetch/ViewV2Fetch.js index 191cb87b54..40135746df 100644 --- a/packages/frontend-core/src/fetch/ViewV2Fetch.js +++ b/packages/frontend-core/src/fetch/ViewV2Fetch.js @@ -39,18 +39,6 @@ export default class ViewV2Fetch extends DataFetch { this.options const { cursor, query, definition } = get(this.store) - // If this is a calculation view and there are no schema fields then do nothing - console.log(definition) - if ( - definition.calculation && - !Object.keys(definition.schema || {}).length - ) { - return { - rows: [], - hasNextPage: false, - } - } - // If sort/filter params are not defined, update options to store the // params built in to this view. This ensures that we can accurately // compare old and new params and skip a redundant API call.