├── .vscode
    └── extensions.json
├── src
    ├── vite-env.d.ts
    ├── lib
    │   ├── dataviewParser.ts
    │   ├── Counter.svelte
    │   ├── templateLoader.ts
    │   ├── MapViewLazy.svelte
    │   ├── MapView.svelte
    │   ├── Toolbox.svelte
    │   ├── About.svelte
    │   ├── DATE_FUNCTIONS.md
    │   ├── BoardView.svelte
    │   ├── GalleryView.svelte
    │   ├── mockDataGeneratorLazy.ts
    │   ├── templateExamples.ts
    │   ├── CalendarView.svelte
    │   ├── mockDataGenerator.ts
    │   ├── BasesUpdater.svelte
    │   ├── basesUpdater.ts
    │   └── DataviewConverter.svelte
    ├── dataview-parser
    │   ├── readme.md
    │   ├── index.ts
    │   ├── source-types.ts
    │   ├── field.ts
    │   ├── normalize.ts
    │   ├── query-types.ts
    │   ├── query-parse.ts
    │   └── expression-parse.ts
    ├── main.ts
    ├── App.svelte
    ├── app.css
    └── assets
    │   └── svelte.svg
├── tsconfig.json
├── svelte.config.js
├── .gitignore
├── index.html
├── public
    └── vite.svg
├── tsconfig.app.json
├── tsconfig.node.json
├── package.json
├── vite.config.ts
├── README.md
└── docs
    └── functions.md


/.vscode/extensions.json:
--------------------------------------------------------------------------------
1 | {
2 |   "recommendations": ["svelte.svelte-vscode"]
3 | }
4 | 


--------------------------------------------------------------------------------
/src/vite-env.d.ts:
--------------------------------------------------------------------------------
1 | /// <reference types="svelte" />
2 | /// <reference types="vite/client" />
3 | 


--------------------------------------------------------------------------------
/src/lib/dataviewParser.ts:
--------------------------------------------------------------------------------
1 | // Re-export the main parsing function from the new parser
2 | export { parseDataviewTable } from "../dataview-parser/index";
3 | 
4 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 |   "files": [],
3 |   "references": [
4 |     { "path": "./tsconfig.app.json" },
5 |     { "path": "./tsconfig.node.json" }
6 |   ]
7 | }
8 | 


--------------------------------------------------------------------------------
/src/dataview-parser/readme.md:
--------------------------------------------------------------------------------
1 | Code for parsing dataview queries.
2 | 
3 | Original code from [Obsidian Dataview](https://github.com/blacksmithgu/obsidian-dataview).
4 | 


--------------------------------------------------------------------------------
/src/main.ts:
--------------------------------------------------------------------------------
 1 | import { mount } from 'svelte'
 2 | import './app.css'
 3 | import App from './App.svelte'
 4 | 
 5 | const app = mount(App, {
 6 |   target: document.getElementById('app')!,
 7 | })
 8 | 
 9 | export default app
10 | 


--------------------------------------------------------------------------------
/src/lib/Counter.svelte:
--------------------------------------------------------------------------------
 1 | <script lang="ts">
 2 |   let count: number = $state(0)
 3 |   const increment = () => {
 4 |     count += 1
 5 |   }
 6 | </script>
 7 | 
 8 | <button onclick={increment}>
 9 |   count is {count}
10 | </button>
11 | 


--------------------------------------------------------------------------------
/svelte.config.js:
--------------------------------------------------------------------------------
1 | import { vitePreprocess } from '@sveltejs/vite-plugin-svelte'
2 | 
3 | export default {
4 |   // Consult https://svelte.dev/docs#compile-time-svelte-preprocess
5 |   // for more information about preprocessors
6 |   preprocess: vitePreprocess(),
7 | }
8 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Logs
 2 | logs
 3 | *.log
 4 | npm-debug.log*
 5 | yarn-debug.log*
 6 | yarn-error.log*
 7 | pnpm-debug.log*
 8 | lerna-debug.log*
 9 | 
10 | node_modules
11 | dist
12 | dist-ssr
13 | *.local
14 | 
15 | # Editor directories and files
16 | .vscode/*
17 | !.vscode/extensions.json
18 | .idea
19 | .DS_Store
20 | *.suo
21 | *.ntvs*
22 | *.njsproj
23 | *.sln
24 | *.sw?
25 | 


--------------------------------------------------------------------------------
/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 |   <head>
 4 |     <meta charset="UTF-8" />
 5 |     <link rel="icon" type="image/svg+xml" href="/vite.svg" />
 6 |     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 7 |     <title>Bases Toolbox</title>
 8 |   </head>
 9 |   <body>
10 |     <div id="app"></div>
11 |     <script type="module" src="/src/main.ts"></script>
12 |   </body>
13 | </html>
14 | 


--------------------------------------------------------------------------------
/public/vite.svg:
--------------------------------------------------------------------------------
1 | <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-hammer-icon lucide-hammer"><path d="m15 12-8.373 8.373a1 1 0 1 1-3-3L12 9"/><path d="m18 15 4-4"/><path d="m21.5 11.5-1.914-1.914A2 2 0 0 1 19 8.172V7l-2.26-2.26a6 6 0 0 0-4.202-1.756L9 2.96l.92.82A6.18 6.18 0 0 1 12 8.4V10l2 2h1.172a2 2 0 0 1 1.414.586L18.5 14.5"/></svg>


--------------------------------------------------------------------------------
/tsconfig.app.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "extends": "@tsconfig/svelte/tsconfig.json",
 3 |   "compilerOptions": {
 4 |     "target": "ESNext",
 5 |     "useDefineForClassFields": true,
 6 |     "module": "ESNext",
 7 |     "resolveJsonModule": true,
 8 |     /**
 9 |      * Typecheck JS in `.svelte` and `.js` files by default.
10 |      * Disable checkJs if you'd like to use dynamic types in JS.
11 |      * Note that setting allowJs false does not prevent the use
12 |      * of JS in `.svelte` files.
13 |      */
14 |     "allowJs": true,
15 |     "checkJs": true,
16 |     "isolatedModules": true,
17 |     "moduleDetection": "force"
18 |   },
19 |   "include": ["src/**/*.ts", "src/**/*.js", "src/**/*.svelte"]
20 | }
21 | 


--------------------------------------------------------------------------------
/tsconfig.node.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
 4 |     "target": "ES2022",
 5 |     "lib": ["ES2023"],
 6 |     "module": "ESNext",
 7 |     "skipLibCheck": true,
 8 | 
 9 |     /* Bundler mode */
10 |     "moduleResolution": "bundler",
11 |     "allowImportingTsExtensions": true,
12 |     "verbatimModuleSyntax": true,
13 |     "moduleDetection": "force",
14 |     "noEmit": true,
15 | 
16 |     /* Linting */
17 |     "strict": true,
18 |     "noUnusedLocals": true,
19 |     "noUnusedParameters": true,
20 |     "erasableSyntaxOnly": true,
21 |     "noFallthroughCasesInSwitch": true,
22 |     "noUncheckedSideEffectImports": true
23 |   },
24 |   "include": ["vite.config.ts"]
25 | }
26 | 


--------------------------------------------------------------------------------
/src/lib/templateLoader.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Lazy loader for template examples to reduce initial bundle size
 3 |  */
 4 | 
 5 | let templatesCache: any = null;
 6 | 
 7 | export async function loadTemplates() {
 8 |   if (templatesCache) {
 9 |     return templatesCache;
10 |   }
11 |   
12 |   try {
13 |     const { baseTemplates } = await import('./templateExamples');
14 |     templatesCache = baseTemplates;
15 |     return baseTemplates;
16 |   } catch (error) {
17 |     console.error('Failed to load templates:', error);
18 |     return {};
19 |   }
20 | }
21 | 
22 | export function getTemplateNames(): string[] {
23 |   if (!templatesCache) {
24 |     return [];
25 |   }
26 |   return Object.keys(templatesCache);
27 | }
28 | 
29 | export function hasTemplatesLoaded(): boolean {
30 |   return templatesCache !== null;
31 | }
32 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "bases-online-preview",
 3 |   "private": true,
 4 |   "version": "0.0.0",
 5 |   "type": "module",
 6 |   "scripts": {
 7 |     "dev": "vite",
 8 |     "build": "vite build",
 9 |     "preview": "vite preview",
10 |     "check": "svelte-check --tsconfig ./tsconfig.app.json && tsc -p tsconfig.node.json"
11 |   },
12 |   "dependencies": {
13 |     "@faker-js/faker": "^9.8.0",
14 |     "@types/js-yaml": "^4.0.9",
15 |     "@types/leaflet": "^1.9.18",
16 |     "@types/luxon": "^3.6.2",
17 |     "@types/parsimmon": "^1.10.9",
18 |     "emoji-regex": "^10.4.0",
19 |     "js-yaml": "^4.1.0",
20 |     "leaflet": "^1.9.4",
21 |     "luxon": "^3.6.1",
22 |     "parsimmon": "^1.18.1"
23 |   },
24 |   "devDependencies": {
25 |     "@sveltejs/vite-plugin-svelte": "^5.0.3",
26 |     "@tsconfig/svelte": "^5.0.4",
27 |     "svelte": "^5.28.1",
28 |     "svelte-check": "^4.1.6",
29 |     "typescript": "~5.8.3",
30 |     "vite": "^6.3.5"
31 |   }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/App.svelte:
--------------------------------------------------------------------------------
 1 | <script lang="ts">
 2 |   import Toolbox from './lib/Toolbox.svelte';
 3 |   import BasesPreview from './lib/BasesPreview.svelte';
 4 | </script>
 5 | 
 6 | <main>
 7 |   <Toolbox>
 8 |     <BasesPreview slot="bases-preview" />
 9 |   </Toolbox>
10 |   <footer>
11 |     <p>All rights @boninall reserved</p>
12 |   </footer>
13 | </main>
14 | 
15 | <style>
16 |   :global(body) {
17 |     margin: 0;
18 |     padding: 0;
19 |     font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
20 |     background-color: #f5f6f8;
21 |     overflow-y: auto;
22 |   }
23 |   
24 |   main {
25 |     height: 100vh;
26 |     display: flex;
27 |     flex-direction: column;
28 |   }
29 |   
30 |   footer {
31 |     background-color: #2c3e50;
32 |     color: #ecf0f1;
33 |     padding: 1rem;
34 |     text-align: center;
35 |     font-size: 0.875rem;
36 |     border-top: 1px solid #34495e;
37 |   }
38 |   
39 |   footer p {
40 |     margin: 0;
41 |   }
42 | </style>
43 | 


--------------------------------------------------------------------------------
/vite.config.ts:
--------------------------------------------------------------------------------
 1 | import { defineConfig } from 'vite'
 2 | import { svelte } from '@sveltejs/vite-plugin-svelte'
 3 | 
 4 | // https://vite.dev/config/
 5 | export default defineConfig({
 6 |   plugins: [svelte()],
 7 |   build: {
 8 |     rollupOptions: {
 9 |       output: {
10 |         manualChunks: {
11 |           // Vendor libraries
12 |           'vendor-core': ['svelte'],
13 |           'vendor-utils': ['js-yaml', 'luxon', 'parsimmon', 'emoji-regex'],
14 |           'vendor-faker': ['@faker-js/faker'],
15 |           'vendor-leaflet': ['leaflet'],
16 | 
17 |           // Application chunks
18 |           'dataview-parser': [
19 |             './src/dataview-parser/index.ts',
20 |             './src/dataview-parser/query-parse.ts',
21 |             './src/dataview-parser/transformer.ts',
22 |             './src/dataview-parser/expression-parse.ts',
23 |             './src/dataview-parser/normalize.ts'
24 |           ],
25 |         }
26 |       }
27 |     },
28 |     // Increase chunk size warning limit to 3000kb since faker.js is intentionally large and lazy-loaded
29 |     chunkSizeWarningLimit: 3000
30 |   }
31 | })
32 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Obsidian Bases Toolbox
 2 | 
 3 | A comprehensive toolbox for working with Obsidian Bases files, featuring:
 4 | 
 5 | 1. **Bases Preview** - Preview and test your Obsidian Bases files
 6 | 2. **Dataview Converter** - Convert Dataview TABLE queries to Bases format
 7 | 
 8 | ## Features
 9 | 
10 | ### Bases Preview
11 | 
12 | - Preview how your .base file will look in Obsidian
13 | - Test different view types: Table, Board, Gallery, Map, Calendar
14 | - Drag and drop a .base file or edit YAML directly
15 | - Try pre-built templates to get started quickly
16 | - Generate random mock data to test your views
17 | 
18 | ### Dataview Converter
19 | 
20 | - Convert existing Dataview TABLE queries to Bases YAML
21 | - Supports most common Dataview features:
22 |   - Fields with aliases
23 |   - FROM source
24 |   - WHERE conditions (AND, OR)
25 |   - SORT with ASC/DESC directions
26 |   - LIMIT and GROUP BY
27 | - Copy converted YAML to create your .base files
28 |  
29 | ## Usage
30 | 
31 | 1. Clone this repository
32 | 2. Install dependencies with `npm install` or `pnpm install`
33 | 3. Run the development server with `npm run dev` or `pnpm dev`
34 | 4. Open your browser to the localhost URL displayed in the terminal
35 | 
36 | ## Development
37 | 
38 | This application is built with:
39 | 
40 | - Svelte
41 | - TypeScript
42 | - Vite
43 | 
44 | ## Building
45 | 
46 | To build for production:
47 | 
48 | ```bash
49 | npm run build
50 | # or
51 | pnpm build
52 | ```
53 | 
54 | The build files will be in the `dist` folder.
55 | 
56 | ## License
57 | 
58 | MIT


--------------------------------------------------------------------------------
/src/dataview-parser/index.ts:
--------------------------------------------------------------------------------
 1 | import { parseQuery } from "./query-parse";
 2 | import { DataviewToBasesTransformer } from "./transformer";
 3 | 
 4 | /**
 5 |  * Parse a Dataview TABLE query and convert it to Bases YAML
 6 |  * @param dataviewQuery The Dataview query string
 7 |  * @param placeFiltersInView Whether to place filters in the view (true) or globally (false)
 8 |  * @returns The Bases YAML string
 9 |  */
10 | export function parseDataviewTable(
11 |   dataviewQuery: string,
12 |   placeFiltersInView: boolean = true
13 | ): string {
14 |   try {
15 |     // Parse the query using Parsimmon parser
16 |     const parseResult = parseQuery(dataviewQuery);
17 | 
18 |     console.log(parseResult);
19 | 
20 |     if (!parseResult.successful) {
21 |       throw new Error(`Failed to parse Dataview query: ${parseResult.error}`);
22 |     }
23 | 
24 |     // Transform the AST to Bases structure
25 |     const transformer = new DataviewToBasesTransformer();
26 |     return transformer.toYaml(parseResult.value, placeFiltersInView);
27 |   } catch (error) {
28 |     console.error("Error parsing Dataview query:", error);
29 |     if (error instanceof Error) {
30 |       return `# Error parsing Dataview query: ${error.message}`;
31 |     }
32 |     return "# Error parsing Dataview query";
33 |   }
34 | }
35 | 
36 | // Re-export types and utilities for external use
37 | export { parseQuery } from "./query-parse";
38 | export { DataviewToBasesTransformer } from "./transformer";
39 | export type { Query, QueryHeader, QueryOperation } from "./query-types";
40 | export type { Field } from "./field";
41 | export type { Source } from "./source-types";
42 | 


--------------------------------------------------------------------------------
/src/app.css:
--------------------------------------------------------------------------------
 1 | :root {
 2 |   font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen,
 3 |     Ubuntu, Cantarell, "Open Sans", "Helvetica Neue", sans-serif;
 4 |   line-height: 1.5;
 5 |   font-weight: 400;
 6 |   color: #333;
 7 |   background-color: #f5f6f8;
 8 | }
 9 | 
10 | * {
11 |   box-sizing: border-box;
12 | }
13 | 
14 | html,
15 | body {
16 |   margin: 0;
17 |   padding: 0;
18 |   height: 100%;
19 |   overflow: hidden; /* 防止滚动 */
20 | }
21 | 
22 | body {
23 |   position: fixed;
24 |   width: 100%;
25 |   height: 100%;
26 | }
27 | 
28 | #app {
29 |   width: 100%;
30 |   height: 100vh;
31 |   margin: 0;
32 |   padding: 0;
33 |   overflow: hidden;
34 | }
35 | 
36 | /* For code/yaml sections */
37 | pre,
38 | code {
39 |   font-family: "Monaco", "Menlo", "Ubuntu Mono", "Consolas", "source-code-pro",
40 |     monospace;
41 | }
42 | 
43 | /* Reset some default button styles */
44 | button {
45 |   border: none;
46 |   background: none;
47 |   font-family: inherit;
48 |   font-size: inherit;
49 |   cursor: pointer;
50 |   padding: 0;
51 | }
52 | 
53 | /* Let our components define their own button styles */
54 | button:focus {
55 |   outline: none;
56 | }
57 | 
58 | /* Add small transition to buttons */
59 | button {
60 |   transition: background-color 0.2s, color 0.2s, border-color 0.2s;
61 | }
62 | 
63 | /* Basic link styles */
64 | a {
65 |   color: #5865f2;
66 |   text-decoration: none;
67 | }
68 | 
69 | a:hover {
70 |   text-decoration: underline;
71 | }
72 | 
73 | /* Scrollbar styling */
74 | ::-webkit-scrollbar {
75 |   width: 8px;
76 |   height: 8px;
77 | }
78 | 
79 | ::-webkit-scrollbar-track {
80 |   background: #f1f1f1;
81 | }
82 | 
83 | ::-webkit-scrollbar-thumb {
84 |   background: #c1c1c1;
85 |   border-radius: 4px;
86 | }
87 | 
88 | ::-webkit-scrollbar-thumb:hover {
89 |   background: #a1a1a1;
90 | }
91 | 


--------------------------------------------------------------------------------
/src/assets/svelte.svg:
--------------------------------------------------------------------------------
1 | <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="26.6" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 308"><path fill="#FF3E00" d="M239.682 40.707C211.113-.182 154.69-12.301 113.895 13.69L42.247 59.356a82.198 82.198 0 0 0-37.135 55.056a86.566 86.566 0 0 0 8.536 55.576a82.425 82.425 0 0 0-12.296 30.719a87.596 87.596 0 0 0 14.964 66.244c28.574 40.893 84.997 53.007 125.787 27.016l71.648-45.664a82.182 82.182 0 0 0 37.135-55.057a86.601 86.601 0 0 0-8.53-55.577a82.409 82.409 0 0 0 12.29-30.718a87.573 87.573 0 0 0-14.963-66.244"></path><path fill="#FFF" d="M106.889 270.841c-23.102 6.007-47.497-3.036-61.103-22.648a52.685 52.685 0 0 1-9.003-39.85a49.978 49.978 0 0 1 1.713-6.693l1.35-4.115l3.671 2.697a92.447 92.447 0 0 0 28.036 14.007l2.663.808l-.245 2.659a16.067 16.067 0 0 0 2.89 10.656a17.143 17.143 0 0 0 18.397 6.828a15.786 15.786 0 0 0 4.403-1.935l71.67-45.672a14.922 14.922 0 0 0 6.734-9.977a15.923 15.923 0 0 0-2.713-12.011a17.156 17.156 0 0 0-18.404-6.832a15.78 15.78 0 0 0-4.396 1.933l-27.35 17.434a52.298 52.298 0 0 1-14.553 6.391c-23.101 6.007-47.497-3.036-61.101-22.649a52.681 52.681 0 0 1-9.004-39.849a49.428 49.428 0 0 1 22.34-33.114l71.664-45.677a52.218 52.218 0 0 1 14.563-6.398c23.101-6.007 47.497 3.036 61.101 22.648a52.685 52.685 0 0 1 9.004 39.85a50.559 50.559 0 0 1-1.713 6.692l-1.35 4.116l-3.67-2.693a92.373 92.373 0 0 0-28.037-14.013l-2.664-.809l.246-2.658a16.099 16.099 0 0 0-2.89-10.656a17.143 17.143 0 0 0-18.398-6.828a15.786 15.786 0 0 0-4.402 1.935l-71.67 45.674a14.898 14.898 0 0 0-6.73 9.975a15.9 15.9 0 0 0 2.709 12.012a17.156 17.156 0 0 0 18.404 6.832a15.841 15.841 0 0 0 4.402-1.935l27.345-17.427a52.147 52.147 0 0 1 14.552-6.397c23.101-6.006 47.497 3.037 61.102 22.65a52.681 52.681 0 0 1 9.003 39.848a49.453 49.453 0 0 1-22.34 33.12l-71.664 45.673a52.218 52.218 0 0 1-14.563 6.398"></path></svg>


--------------------------------------------------------------------------------
/src/lib/MapViewLazy.svelte:
--------------------------------------------------------------------------------
 1 | <script lang="ts">
 2 |   import { onMount } from 'svelte';
 3 |   
 4 |   export let files: any[] = [];
 5 |   export let latField: string = 'lat';
 6 |   export let longField: string = 'long';
 7 |   export let titleField: string = 'file.name';
 8 |   
 9 |   let MapViewComponent: any = null;
10 |   let loading = true;
11 |   let error: string | null = null;
12 |   
13 |   onMount(async () => {
14 |     try {
15 |       // Dynamically import the MapView component and Leaflet
16 |       const { default: MapView } = await import('./MapView.svelte');
17 |       MapViewComponent = MapView;
18 |       loading = false;
19 |     } catch (err) {
20 |       console.error('Failed to load MapView component:', err);
21 |       error = 'Failed to load map component';
22 |       loading = false;
23 |     }
24 |   });
25 | </script>
26 | 
27 | {#if loading}
28 |   <div class="loading-container">
29 |     <div class="loading-spinner"></div>
30 |     <p>Loading map component...</p>
31 |   </div>
32 | {:else if error}
33 |   <div class="error-container">
34 |     <p>Error: {error}</p>
35 |   </div>
36 | {:else if MapViewComponent}
37 |   <svelte:component 
38 |     this={MapViewComponent} 
39 |     {files} 
40 |     {latField} 
41 |     {longField} 
42 |     {titleField} 
43 |   />
44 | {/if}
45 | 
46 | <style>
47 |   .loading-container {
48 |     display: flex;
49 |     flex-direction: column;
50 |     align-items: center;
51 |     justify-content: center;
52 |     height: 400px;
53 |     color: #666;
54 |   }
55 |   
56 |   .loading-spinner {
57 |     width: 40px;
58 |     height: 40px;
59 |     border: 4px solid #f3f3f3;
60 |     border-top: 4px solid #3498db;
61 |     border-radius: 50%;
62 |     animation: spin 1s linear infinite;
63 |     margin-bottom: 16px;
64 |   }
65 |   
66 |   @keyframes spin {
67 |     0% { transform: rotate(0deg); }
68 |     100% { transform: rotate(360deg); }
69 |   }
70 |   
71 |   .error-container {
72 |     display: flex;
73 |     align-items: center;
74 |     justify-content: center;
75 |     height: 400px;
76 |     color: #e74c3c;
77 |     background-color: #fdf2f2;
78 |     border: 1px solid #f5c6cb;
79 |     border-radius: 4px;
80 |   }
81 | </style>
82 | 


--------------------------------------------------------------------------------
/src/lib/MapView.svelte:
--------------------------------------------------------------------------------
  1 | <script lang="ts">
  2 |   import { onMount, onDestroy } from 'svelte';
  3 |   import L from 'leaflet';
  4 |   import 'leaflet/dist/leaflet.css';
  5 |   
  6 |   export let files: any[] = [];
  7 |   export let latField: string = 'lat';
  8 |   export let longField: string = 'long';
  9 |   export let titleField: string = 'file.name';
 10 |   
 11 |   let mapElement: HTMLElement;
 12 |   let map: L.Map;
 13 |   let markers: L.Marker[] = [];
 14 |   
 15 |   // Set up the map when the component mounts
 16 |   onMount(() => {
 17 |     // Create the map
 18 |     map = L.map(mapElement).setView([0, 0], 2);
 19 |     
 20 |     // Add OpenStreetMap tile layer
 21 |     L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
 22 |       attribution: '&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors'
 23 |     }).addTo(map);
 24 |     
 25 |     // Add markers for files with coordinates
 26 |     updateMarkers();
 27 |   });
 28 |   
 29 |   // Clean up when the component is destroyed
 30 |   onDestroy(() => {
 31 |     if (map) {
 32 |       map.remove();
 33 |     }
 34 |   });
 35 |   
 36 |   // Function to update markers when files change
 37 |   $: if (map && files) {
 38 |     updateMarkers();
 39 |   }
 40 |   
 41 |   function updateMarkers() {
 42 |     // Clear existing markers
 43 |     markers.forEach(marker => {
 44 |       map.removeLayer(marker);
 45 |     });
 46 |     markers = [];
 47 |     
 48 |     // Only process files with coordinates
 49 |     const filesWithCoords = files.filter(file => 
 50 |       typeof getPropertyValue(file, latField) === 'number' && 
 51 |       typeof getPropertyValue(file, longField) === 'number'
 52 |     );
 53 |     
 54 |     if (filesWithCoords.length === 0) {
 55 |       // Default view if no markers
 56 |       map.setView([0, 0], 2);
 57 |       return;
 58 |     }
 59 |     
 60 |     // Add new markers
 61 |     const bounds = L.latLngBounds([]);
 62 |     
 63 |     filesWithCoords.forEach(file => {
 64 |       const lat = getPropertyValue(file, latField);
 65 |       const lng = getPropertyValue(file, longField);
 66 |       const title = getPropertyValue(file, titleField) || 'Unnamed';
 67 |       
 68 |       const marker = L.marker([lat, lng])
 69 |         .addTo(map)
 70 |         .bindPopup(`<b>${title}</b><br>Lat: ${lat}<br>Long: ${lng}`);
 71 |       
 72 |       markers.push(marker);
 73 |       bounds.extend([lat, lng]);
 74 |     });
 75 |     
 76 |     // Fit the map to show all markers
 77 |     if (filesWithCoords.length > 0) {
 78 |       map.fitBounds(bounds, { padding: [50, 50] });
 79 |     }
 80 |   }
 81 |   
 82 |   // Helper function to get property values
 83 |   function getPropertyValue(file: any, propPath: string): any {
 84 |     if (!propPath) return undefined;
 85 |     
 86 |     // Handle file properties
 87 |     if (propPath.startsWith('file.')) {
 88 |       const key = propPath.substring(5);
 89 |       return file.file[key];
 90 |     }
 91 |     
 92 |     // Regular properties
 93 |     return file[propPath];
 94 |   }
 95 | </script>
 96 | 
 97 | <style>
 98 |   .map-container {
 99 |     height: 100%;
100 |     width: 100%;
101 |     min-height: 400px;
102 |     position: relative;
103 |   }
104 |   
105 |   :global(.leaflet-container) {
106 |     height: 100%;
107 |     width: 100%;
108 |   }
109 |   
110 |   /* Add some Leaflet style fixes */
111 |   :global(.leaflet-control-attribution) {
112 |     font-size: 10px;
113 |   }
114 |   
115 |   :global(.leaflet-popup-content) {
116 |     margin: 10px;
117 |     line-height: 1.4;
118 |   }
119 |   
120 |   :global(.leaflet-popup-content b) {
121 |     font-weight: 600;
122 |     margin-bottom: 4px;
123 |     display: block;
124 |   }
125 | </style>
126 | 
127 | <div class="map-container" bind:this={mapElement}></div> 


--------------------------------------------------------------------------------
/src/dataview-parser/source-types.ts:
--------------------------------------------------------------------------------
  1 | /** AST implementation for queries over data sources. */
  2 | 
  3 | /** The source of files for a query. */
  4 | export type Source =
  5 |   | TagSource
  6 |   | CsvSource
  7 |   | FolderSource
  8 |   | LinkSource
  9 |   | EmptySource
 10 |   | NegatedSource
 11 |   | BinaryOpSource;
 12 | /** Valid operations for combining sources. */
 13 | export type SourceOp = "&" | "|";
 14 | 
 15 | /** A tag as a source of data. */
 16 | export interface TagSource {
 17 |   type: "tag";
 18 |   /** The tag to source from. */
 19 |   tag: string;
 20 | }
 21 | 
 22 | /** A csv as a source of data. */
 23 | export interface CsvSource {
 24 |   type: "csv";
 25 |   /** The path to the CSV file. */
 26 |   path: string;
 27 | }
 28 | 
 29 | /** A folder prefix as a source of data. */
 30 | export interface FolderSource {
 31 |   type: "folder";
 32 |   /** The folder prefix to source from. */
 33 |   folder: string;
 34 | }
 35 | 
 36 | /** Either incoming or outgoing links to a given file. */
 37 | export interface LinkSource {
 38 |   type: "link";
 39 |   /** The file to look for links to/from.  */
 40 |   file: string;
 41 |   /**
 42 |    * The direction to look - if incoming, then all files linking to the target file. If outgoing, then all files
 43 |    * which the file links to.
 44 |    */
 45 |   direction: "incoming" | "outgoing";
 46 | }
 47 | 
 48 | /** A source which is everything EXCEPT the files returned by the given source. */
 49 | export interface NegatedSource {
 50 |   type: "negate";
 51 |   /** The source to negate. */
 52 |   child: Source;
 53 | }
 54 | 
 55 | /** A source which yields nothing. */
 56 | export interface EmptySource {
 57 |   type: "empty";
 58 | }
 59 | 
 60 | /** A source made by combining subsources with a logical operators. */
 61 | export interface BinaryOpSource {
 62 |   type: "binaryop";
 63 |   op: SourceOp;
 64 |   left: Source;
 65 |   right: Source;
 66 | }
 67 | 
 68 | /** Utility functions for creating and manipulating sources. */
 69 | export namespace Sources {
 70 |   /** Create a source which searches from a tag. */
 71 |   export function tag(tag: string): TagSource {
 72 |     return { type: "tag", tag };
 73 |   }
 74 | 
 75 |   /** Create a source which fetches from a CSV file. */
 76 |   export function csv(path: string): CsvSource {
 77 |     return { type: "csv", path };
 78 |   }
 79 | 
 80 |   /** Create a source which searches for files under a folder prefix. */
 81 |   export function folder(prefix: string): FolderSource {
 82 |     return { type: "folder", folder: prefix };
 83 |   }
 84 | 
 85 |   /** Create a source which searches for files which link to/from a given file. */
 86 |   export function link(file: string, incoming: boolean): LinkSource {
 87 |     return {
 88 |       type: "link",
 89 |       file,
 90 |       direction: incoming ? "incoming" : "outgoing",
 91 |     };
 92 |   }
 93 | 
 94 |   /** Create a source which joins two sources by a logical operator (and/or). */
 95 |   export function binaryOp(left: Source, op: SourceOp, right: Source): Source {
 96 |     return { type: "binaryop", left, op, right };
 97 |   }
 98 | 
 99 |   /** Create a source which takes the intersection of two sources. */
100 |   export function and(left: Source, right: Source): Source {
101 |     return { type: "binaryop", left, op: "&", right };
102 |   }
103 | 
104 |   /** Create a source which takes the union of two sources. */
105 |   export function or(left: Source, right: Source): Source {
106 |     return { type: "binaryop", left, op: "|", right };
107 |   }
108 | 
109 |   /** Create a source which negates the underlying source. */
110 |   export function negate(child: Source): NegatedSource {
111 |     return { type: "negate", child };
112 |   }
113 | 
114 |   export function empty(): EmptySource {
115 |     return { type: "empty" };
116 |   }
117 | }
118 | 


--------------------------------------------------------------------------------
/src/lib/Toolbox.svelte:
--------------------------------------------------------------------------------
  1 | <script lang="ts">
  2 |   import { onMount } from 'svelte';
  3 |   import DataviewConverter from './DataviewConverter.svelte';
  4 |   import BasesUpdater from './BasesUpdater.svelte';
  5 |   import About from './About.svelte';
  6 |   
  7 |   // Toolbox tabs
  8 |   const TABS = {
  9 |     BASES_PREVIEW: 'bases-preview',
 10 |     DATAVIEW_CONVERTER: 'dataview-converter',
 11 |     BASES_UPDATER: 'bases-updater',
 12 |     ABOUT: 'about'
 13 |   };
 14 |   
 15 |   // Active tab state
 16 |   let activeTab = TABS.DATAVIEW_CONVERTER;
 17 |   
 18 |   // Set active tab
 19 |   function setActiveTab(tab: string) {
 20 |     activeTab = tab;
 21 |   }
 22 |   
 23 |   onMount(() => {
 24 |     // Check if there's a tab in the URL hash
 25 |     const hash = window.location.hash.substring(1);
 26 |     if (hash && Object.values(TABS).includes(hash)) {
 27 |       activeTab = hash;
 28 |     }
 29 |   });
 30 |   
 31 |   // Update URL hash when tab changes
 32 |   $: {
 33 |     if (typeof window !== 'undefined') {
 34 |       window.location.hash = activeTab;
 35 |     }
 36 |   }
 37 | </script>
 38 | 
 39 | <div class="toolbox-container">
 40 |   <div class="toolbox-header">
 41 |     <div class="toolbox-tabs">
 42 |       <button 
 43 |         class={activeTab === TABS.BASES_PREVIEW ? 'active' : ''}
 44 |         on:click={() => setActiveTab(TABS.BASES_PREVIEW)}
 45 |       >
 46 |         Bases Preview
 47 |       </button>
 48 |       <button 
 49 |         class={activeTab === TABS.DATAVIEW_CONVERTER ? 'active' : ''}
 50 |         on:click={() => setActiveTab(TABS.DATAVIEW_CONVERTER)}
 51 |       >
 52 |         Dataview Converter
 53 |       </button>
 54 |       <button 
 55 |         class={activeTab === TABS.BASES_UPDATER ? 'active' : ''}
 56 |         on:click={() => setActiveTab(TABS.BASES_UPDATER)}
 57 |       >
 58 |         Bases Updater
 59 |       </button>
 60 |       <button 
 61 |         class={activeTab === TABS.ABOUT ? 'active' : ''}
 62 |         on:click={() => setActiveTab(TABS.ABOUT)}
 63 |       >
 64 |         About
 65 |       </button>
 66 |     </div>
 67 |     <div class="toolbox-header-right">
 68 |       <button aria-label="github"  on:click={() => window.open('https://github.com/quorafind/bases-toolbox', '_blank')}>
 69 |         <svg width="32" height="32" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
 70 |           <path fill-rule="evenodd" clip-rule="evenodd" d="M12 2C6.477 2 2 6.477 2 12c0 4.418 2.865 8.166 6.839 9.489.5.092.682-.217.682-.482 0-.237-.009-.866-.014-1.7-2.782.603-3.369-1.34-3.369-1.34-.454-1.156-1.11-1.464-1.11-1.464-.908-.62.069-.608.069-.608 1.003.07 1.531 1.03 1.531 1.03.892 1.529 2.341 1.088 2.91.832.092-.646.35-1.086.636-1.336-2.22-.253-4.555-1.11-4.555-4.943 0-1.091.39-1.984 1.029-2.683-.103-.253-.446-1.27.098-2.647 0 0 .84-.268 2.75 1.026A9.578 9.578 0 0112 6.836c.85.004 1.705.114 2.504.336 1.909-1.294 2.747-1.026 2.747-1.026.546 1.377.202 2.394.1 2.647.64.699 1.028 1.592 1.028 2.683 0 3.842-2.339 4.687-4.566 4.935.359.309.678.919.678 1.852 0 1.336-.012 2.415-.012 2.743 0 .267.18.578.688.48C19.138 20.161 22 16.416 22 12c0-5.523-4.477-10-10-10z" fill="#24292F"/>
 71 |         </svg>
 72 |       </button>
 73 |     </div>
 74 |   </div>
 75 |   
 76 |   <div class="toolbox-content">
 77 |     {#if activeTab === TABS.BASES_PREVIEW}
 78 |       <slot name="bases-preview"></slot>
 79 |     {:else if activeTab === TABS.DATAVIEW_CONVERTER}
 80 |       <DataviewConverter />
 81 |     {:else if activeTab === TABS.BASES_UPDATER}
 82 |       <BasesUpdater />
 83 |     {:else if activeTab === TABS.ABOUT}
 84 |       <About />
 85 |     {/if}
 86 |   </div>
 87 | </div>
 88 | 
 89 | <style>
 90 |   .toolbox-container {
 91 |     max-width: 100%;
 92 |     height: 100vh;
 93 |     display: flex;
 94 |     flex-direction: column;
 95 |   }
 96 |   
 97 |   .toolbox-header {
 98 |     padding: 8px 20px;
 99 |     background-color: #f5f6f8;
100 |     border-bottom: 1px solid #e1e2e5;
101 |     flex: 0 0 auto;
102 |     display: flex;
103 |     align-items: center;
104 |     width: 100%;
105 |     justify-content: space-between;
106 |   }
107 |   
108 |   .toolbox-tabs {
109 |     display: flex;
110 |     gap: 10px;
111 |     justify-content: flex-start;
112 |   }
113 |   
114 |   .toolbox-tabs button {
115 |     background: white;
116 |     border: 1px solid #ddd;
117 |     border-radius: 8px;
118 |     padding: 8px 20px;
119 |     font-size: 16px;
120 |     cursor: pointer;
121 |     color: #555;
122 |     transition: all 0.2s ease;
123 |   }
124 |   
125 |   .toolbox-tabs button:hover {
126 |     background: #f9f9f9;
127 |     border-color: #ccc;
128 |   }
129 |   
130 |   .toolbox-tabs button.active {
131 |     background: #50567a;
132 |     color: white;
133 |     border-color: #50567a;
134 |   }
135 |   
136 |   .toolbox-content {
137 |     flex: 1;
138 |     overflow-y: auto;
139 |     padding: 20px;
140 |   }
141 | </style> 


--------------------------------------------------------------------------------
/src/dataview-parser/field.ts:
--------------------------------------------------------------------------------
  1 | import { DateTime, Duration } from "luxon";
  2 | import type { Link } from "./normalize";
  3 | /** Defines the AST for a field which can be evaluated. */
  4 | export type Literal =
  5 |   | boolean
  6 |   | number
  7 |   | string
  8 |   | Array<Literal>
  9 |   | Function
 10 |   | null
 11 |   | HTMLElement
 12 |   | DateTime
 13 |   | Duration
 14 |   | Link;
 15 | 
 16 | /** Comparison operators which yield true/false. */
 17 | export type CompareOp = ">" | ">=" | "<=" | "<" | "=" | "!=";
 18 | /** Arithmetic operators which yield numbers and other values. */
 19 | export type ArithmeticOp = "+" | "-" | "*" | "/" | "%" | "&" | "|";
 20 | /** All valid binary operators. */
 21 | export type BinaryOp = CompareOp | ArithmeticOp;
 22 | /** A (potentially computed) field to select or compare against. */
 23 | export type Field =
 24 |   | BinaryOpField
 25 |   | VariableField
 26 |   | LiteralField
 27 |   | FunctionField
 28 |   | IndexField
 29 |   | NegatedField
 30 |   | LambdaField
 31 |   | ObjectField
 32 |   | ListField;
 33 | 
 34 | /** Literal representation of some field type. */
 35 | export interface LiteralField {
 36 |   type: "literal";
 37 |   value: Literal;
 38 | }
 39 | 
 40 | /** A variable field for a variable with a given name. */
 41 | export interface VariableField {
 42 |   type: "variable";
 43 |   name: string;
 44 | }
 45 | 
 46 | /** A list, which is an ordered collection of fields. */
 47 | export interface ListField {
 48 |   type: "list";
 49 |   values: Field[];
 50 | }
 51 | 
 52 | /** An object, which is a mapping of name to field. */
 53 | export interface ObjectField {
 54 |   type: "object";
 55 |   values: Record<string, Field>;
 56 | }
 57 | 
 58 | /** A binary operator field which combines two subnodes somehow. */
 59 | export interface BinaryOpField {
 60 |   type: "binaryop";
 61 |   left: Field;
 62 |   right: Field;
 63 |   op: BinaryOp;
 64 | }
 65 | 
 66 | /** A function field which calls a function on 0 or more arguments. */
 67 | export interface FunctionField {
 68 |   type: "function";
 69 |   /** Either the name of the function being called, or a Function object. */
 70 |   func: Field;
 71 |   /** The arguments being passed to the function. */
 72 |   arguments: Field[];
 73 | }
 74 | 
 75 | export interface LambdaField {
 76 |   type: "lambda";
 77 |   /** An ordered list of named arguments. */
 78 |   arguments: string[];
 79 |   /** The field which should be evaluated with the arguments in context. */
 80 |   value: Field;
 81 | }
 82 | 
 83 | /** A field which indexes a variable into another variable. */
 84 | export interface IndexField {
 85 |   type: "index";
 86 |   /** The field to index into. */
 87 |   object: Field;
 88 |   /** The index. */
 89 |   index: Field;
 90 | }
 91 | 
 92 | /** A field which negates the value of the original field. */
 93 | export interface NegatedField {
 94 |   type: "negated";
 95 |   /** The child field to negated. */
 96 |   child: Field;
 97 | }
 98 | 
 99 | /** Utility methods for creating & comparing fields. */
100 | export namespace Fields {
101 |   export function variable(name: string): VariableField {
102 |     return { type: "variable", name };
103 |   }
104 | 
105 |   export function literal(value: Literal): LiteralField {
106 |     return { type: "literal", value };
107 |   }
108 | 
109 |   export function binaryOp(left: Field, op: BinaryOp, right: Field): Field {
110 |     return { type: "binaryop", left, op, right } as BinaryOpField;
111 |   }
112 | 
113 |   export function index(obj: Field, index: Field): IndexField {
114 |     return { type: "index", object: obj, index };
115 |   }
116 | 
117 |   /** Converts a string in dot-notation-format into a variable which indexes. */
118 |   export function indexVariable(name: string): Field {
119 |     let parts = name.split(".");
120 |     let result: Field = Fields.variable(parts[0]);
121 |     for (let index = 1; index < parts.length; index++) {
122 |       result = Fields.index(result, Fields.literal(parts[index]));
123 |     }
124 | 
125 |     return result;
126 |   }
127 | 
128 |   export function lambda(args: string[], value: Field): LambdaField {
129 |     return { type: "lambda", arguments: args, value };
130 |   }
131 | 
132 |   export function func(func: Field, args: Field[]): FunctionField {
133 |     return { type: "function", func, arguments: args };
134 |   }
135 | 
136 |   export function list(values: Field[]): ListField {
137 |     return { type: "list", values };
138 |   }
139 | 
140 |   export function object(values: Record<string, Field>): ObjectField {
141 |     return { type: "object", values };
142 |   }
143 | 
144 |   export function negate(child: Field): NegatedField {
145 |     return { type: "negated", child };
146 |   }
147 | 
148 |   export function isCompareOp(op: BinaryOp): op is CompareOp {
149 |     return (
150 |       op == "<=" ||
151 |       op == "<" ||
152 |       op == ">" ||
153 |       op == ">=" ||
154 |       op == "!=" ||
155 |       op == "="
156 |     );
157 |   }
158 | 
159 |   export const NULL = Fields.literal(null);
160 | }
161 | 


--------------------------------------------------------------------------------
/src/lib/About.svelte:
--------------------------------------------------------------------------------
  1 | <div class="about-container">
  2 |   <div class="about-content">
  3 |     <h1>About Bases Toolbox</h1>
  4 |     
  5 |     <p>
  6 |       Bases Toolbox is a comprehensive online preview tool designed to help you work with Obsidian's Bases feature more effectively. 
  7 |       This project provides various utilities and preview capabilities to enhance your productivity when working with structured data in Obsidian.
  8 |     </p>
  9 |     
 10 |     <h2>Features</h2>
 11 |     <ul>
 12 |       <li><strong>Bases Preview:</strong> Visualize and interact with your Bases data in different views (Table, Calendar, Gallery, Board, Map)</li>
 13 |       <li><strong>Dataview Converter:</strong> Convert Dataview queries to Bases format seamlessly</li>
 14 |       <li><strong>Live Preview:</strong> See real-time updates as you modify your queries</li>
 15 |       <li><strong>Multiple View Types:</strong> Support for various data visualization formats</li>
 16 |     </ul>
 17 |     
 18 |     <h2>Learn More About Bases</h2>
 19 |     <p>
 20 |       For detailed information about Obsidian's Bases feature and how to use it effectively, 
 21 |       please visit the official documentation:
 22 |     </p>
 23 |     <a href="https://help.obsidian.md/bases" target="_blank" rel="noopener noreferrer" class="docs-link">
 24 |       <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
 25 |         <path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"></path>
 26 |         <polyline points="15 3 21 3 21 9"></polyline>
 27 |         <line x1="10" y1="14" x2="21" y2="3"></line>
 28 |       </svg>
 29 |       Obsidian Bases Documentation
 30 |     </a>
 31 |     
 32 |     <h2>Open Source</h2>
 33 |     <p>
 34 |       This project is open source and available on GitHub. Contributions, bug reports, and feature requests are welcome!
 35 |     </p>
 36 |     
 37 |     <div class="github-section">
 38 |       <a href="https://github.com/quorafind/bases-toolbox" target="_blank" rel="noopener noreferrer" class="github-link">
 39 |         <svg width="32" height="32" viewBox="0 0 24 24" fill="none" class="github-icon" xmlns="http://www.w3.org/2000/svg">
 40 |             <path fill-rule="evenodd" clip-rule="evenodd" d="M12 2C6.477 2 2 6.477 2 12c0 4.418 2.865 8.166 6.839 9.489.5.092.682-.217.682-.482 0-.237-.009-.866-.014-1.7-2.782.603-3.369-1.34-3.369-1.34-.454-1.156-1.11-1.464-1.11-1.464-.908-.62.069-.608.069-.608 1.003.07 1.531 1.03 1.531 1.03.892 1.529 2.341 1.088 2.91.832.092-.646.35-1.086.636-1.336-2.22-.253-4.555-1.11-4.555-4.943 0-1.091.39-1.984 1.029-2.683-.103-.253-.446-1.27.098-2.647 0 0 .84-.268 2.75 1.026A9.578 9.578 0 0112 6.836c.85.004 1.705.114 2.504.336 1.909-1.294 2.747-1.026 2.747-1.026.546 1.377.202 2.394.1 2.647.64.699 1.028 1.592 1.028 2.683 0 3.842-2.339 4.687-4.566 4.935.359.309.678.919.678 1.852 0 1.336-.012 2.415-.012 2.743 0 .267.18.578.688.48C19.138 20.161 22 16.416 22 12c0-5.523-4.477-10-10-10z" fill="white"/>
 41 |           </svg>
 42 |         View on GitHub
 43 |       </a>
 44 |     </div>
 45 |   </div>
 46 | </div>
 47 | 
 48 | <style>
 49 |   .about-container {
 50 |     max-width: 1000px;
 51 |     margin: 0 auto;
 52 |   }
 53 |   
 54 |   .about-content {
 55 |     background: white;
 56 |     border-radius: 12px;
 57 |     padding: 3rem;
 58 |     box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
 59 |   }
 60 |   
 61 |   h1 {
 62 |     color: #2c3e50;
 63 |     margin-bottom: 1.5rem;
 64 |     font-size: 2.5rem;
 65 |   }
 66 |   
 67 |   h2 {
 68 |     color: #34495e;
 69 |     margin-top: 2rem;
 70 |     margin-bottom: 1rem;
 71 |     font-size: 1.5rem;
 72 |   }
 73 |   
 74 |   p {
 75 |     color: #555;
 76 |     line-height: 1.6;
 77 |     margin-bottom: 1rem;
 78 |   }
 79 |   
 80 |   ul {
 81 |     color: #555;
 82 |     line-height: 1.8;
 83 |     padding-left: 1.5rem;
 84 |   }
 85 |   
 86 |   li {
 87 |     margin-bottom: 0.5rem;
 88 |   }
 89 |   
 90 |   .docs-link {
 91 |     display: inline-flex;
 92 |     align-items: center;
 93 |     gap: 0.5rem;
 94 |     color: #50567a;
 95 |     text-decoration: none;
 96 |     font-weight: 500;
 97 |     padding: 0.75rem 1.5rem;
 98 |     background: #f0f2f5;
 99 |     border-radius: 8px;
100 |     transition: all 0.2s ease;
101 |     margin: 1rem 0;
102 |   }
103 |   
104 |   .docs-link:hover {
105 |     background: #e1e4e8;
106 |     transform: translateY(-1px);
107 |   }
108 |   
109 |   .github-section {
110 |     margin-top: 2rem;
111 |     text-align: center;
112 |   }
113 |   
114 |   .github-link {
115 |     display: inline-flex;
116 |     align-items: center;
117 |     gap: 0.5rem;
118 |     color: white;
119 |     text-decoration: none;
120 |     font-weight: 500;
121 |     padding: 0.75rem 1.5rem;
122 |     background: #24292F;
123 |     border-radius: 8px;
124 |     transition: all 0.2s ease;
125 |   }
126 |   
127 |   .github-link:hover {
128 |     background: #1a1e22;
129 |     transform: translateY(-1px);
130 |   }
131 | 
132 |   .github-icon {
133 |     color: white;
134 |   }
135 | </style> 


--------------------------------------------------------------------------------
/src/lib/DATE_FUNCTIONS.md:
--------------------------------------------------------------------------------
  1 | # Dataview to Bases Date Function Conversion
  2 | 
  3 | This document explains how Dataview date expressions are converted to Bases date functions.
  4 | 
  5 | ## Supported Date Conversions
  6 | 
  7 | | Dataview Syntax                           | Bases Syntax                   | Description                     |
  8 | | ----------------------------------------- | ------------------------------ | ------------------------------- |
  9 | | `date(today)`                             | `now()`                        | Current date and time           |
 10 | | `date(yesterday)`                         | `dateModify(now(), "-1 day")`  | Yesterday's date                |
 11 | | `date(tomorrow)`                          | `dateModify(now(), "1 day")`   | Tomorrow's date                 |
 12 | | `dur(N days)`                             | `"N days"`                     | Duration of N days              |
 13 | | `dur(N weeks)`                            | `"N weeks"`                    | Duration of N weeks             |
 14 | | `dur(N months)`                           | `"N months"`                   | Duration of N months            |
 15 | | `expr + dur(N units)`                     | `dateModify(expr, "N units")`  | Add a duration to a date        |
 16 | | `expr - dur(N units)`                     | `dateModify(expr, "-N units")` | Subtract a duration from a date |
 17 | | `now() + "N units"` or `expr + "N units"` | `dateModify(expr, "N units")`  | Add a string duration to a date |
 18 | | `now() - "N units"` or `expr - "N units"` | `dateModify(expr, "-N units")` | Subtract a string duration      |
 19 | 
 20 | ## Examples
 21 | 
 22 | ### Example 1: Due date within the next week
 23 | 
 24 | **Dataview:**
 25 | 
 26 | ```
 27 | due >= date(today) AND due <= date(today) + dur(7 days)
 28 | ```
 29 | 
 30 | **Bases:**
 31 | 
 32 | ```
 33 | due >= now() AND due <= dateModify(now(), "7 days")
 34 | ```
 35 | 
 36 | ### Example 2: Completed yesterday
 37 | 
 38 | **Dataview:**
 39 | 
 40 | ```
 41 | completion = date(yesterday)
 42 | ```
 43 | 
 44 | **Bases:**
 45 | 
 46 | ```
 47 | completion == dateModify(now(), "-1 day")
 48 | ```
 49 | 
 50 | ### Example 3: Starting within the past two weeks
 51 | 
 52 | **Dataview:**
 53 | 
 54 | ```
 55 | start_date >= date(today) - dur(2 weeks)
 56 | ```
 57 | 
 58 | **Bases:**
 59 | 
 60 | ```
 61 | start_date >= dateModify(now(), "-2 weeks")
 62 | ```
 63 | 
 64 | ### Example 4: Due tomorrow
 65 | 
 66 | **Dataview:**
 67 | 
 68 | ```
 69 | deadline < date(tomorrow)
 70 | ```
 71 | 
 72 | **Bases:**
 73 | 
 74 | ```
 75 | deadline < dateModify(now(), "1 day")
 76 | ```
 77 | 
 78 | ### Example 5: Expression with date first
 79 | 
 80 | **Dataview:**
 81 | 
 82 | ```
 83 | (date(today) + dur(5 days)) > due_date
 84 | ```
 85 | 
 86 | **Bases:**
 87 | 
 88 | ```
 89 | dateModify(now(), "5 days") > due_date
 90 | ```
 91 | 
 92 | ### Example 6: Field with already converted duration
 93 | 
 94 | **Dataview (after partial conversion):**
 95 | 
 96 | ```
 97 | due >= now() AND due <= now() + "7 days"
 98 | ```
 99 | 
100 | **Final Bases:**
101 | 
102 | ```
103 | due >= now() AND due <= dateModify(now(), "7 days")
104 | ```
105 | 
106 | ## Multi-Stage Processing Explained
107 | 
108 | The date conversion happens in two stages:
109 | 
110 | 1. First, Dataview date functions are converted:
111 | 
112 |    - `date(today)` becomes `now()`
113 |    - `date(tomorrow)` becomes `dateModify(now(), "1 day")`
114 |    - `date(yesterday)` becomes `dateModify(now(), "-1 day")`
115 |    - `dur(7 days)` becomes `"7 days"`
116 | 
117 | 2. Then, date math expressions are converted:
118 |    - `now() + "7 days"` becomes `dateModify(now(), "7 days")`
119 |    - `date_field - "2 weeks"` becomes `dateModify(date_field, "-2 weeks")`
120 |    - `date(today) + dur(3 months)` becomes `dateModify(now(), "3 months")`
121 | 
122 | This multi-stage process ensures all date calculations are properly converted to Bases format.
123 | 
124 | ## Available Bases Date Functions
125 | 
126 | All of these Bases date functions are supported:
127 | 
128 | - `now()` - Returns the current date and time
129 | - `dateModify(datetime, duration)` - Modifies a date by a duration
130 | - `date_diff(datetime1, datetime2)` - Gets the difference between two dates in milliseconds
131 | - `dateEquals(datetime1, datetime2)` - Checks if two dates are equal
132 | - `dateNotEquals(datetime1, datetime2)` - Checks if two dates are not equal
133 | - `dateBefore(datetime1, datetime2)` - Checks if the first date is before the second
134 | - `dateAfter(datetime1, datetime2)` - Checks if the first date is after the second
135 | - `dateOnOrBefore(datetime1, datetime2)` - Checks if the first date is on or before the second
136 | - `dateOnOrAfter(datetime1, datetime2)` - Checks if the first date is on or after the second
137 | - `year(date)` - Gets the year from a date
138 | - `month(date)` - Gets the month from a date
139 | - `day(date)` - Gets the day from a date
140 | - `hour(datetime)` - Gets the hour from a date
141 | - `minute(datetime)` - Gets the minute from a date
142 | - `second(datetime)` - Gets the second from a date
143 | 


--------------------------------------------------------------------------------
/src/lib/BoardView.svelte:
--------------------------------------------------------------------------------
  1 | <script lang="ts">
  2 |   import { getPropertyValue } from './basesParser';
  3 |   
  4 |   export let files: any[] = [];
  5 |   export let groupBy: string = 'status';
  6 |   export let titleField: string = 'file.name';
  7 |   export let descriptionField: string = 'summary';
  8 |   export let limit: number = 50;
  9 |   
 10 |   // Get unique group values
 11 |   $: groupValues = [...new Set(files.map(file => getPropertyValue(file, groupBy)))].filter(Boolean);
 12 |   
 13 |   // Group files by the selected property
 14 |   $: groupedFiles = groupFiles(files, groupBy, limit);
 15 |   
 16 |   function groupFiles(files: any[], groupBy: string, limit: number) {
 17 |     const grouped: Record<string, any[]> = {};
 18 |     
 19 |     // Initialize with empty arrays for each group
 20 |     groupValues.forEach(value => {
 21 |       grouped[value] = [];
 22 |     });
 23 |     
 24 |     // Group files by the specified property
 25 |     files.forEach(file => {
 26 |       const value = getPropertyValue(file, groupBy);
 27 |       if (value && grouped[value]) {
 28 |         if (grouped[value].length < limit) {
 29 |           grouped[value].push(file);
 30 |         }
 31 |       }
 32 |     });
 33 |     
 34 |     return grouped;
 35 |   }
 36 |   
 37 |   // Get a color for a group based on its name
 38 |   function getGroupColor(groupName: string): string {
 39 |     // Simple hash function to generate a color from a string
 40 |     const hash = groupName.split('').reduce((acc, char) => {
 41 |       return char.charCodeAt(0) + ((acc << 5) - acc);
 42 |     }, 0);
 43 |     
 44 |     const h = Math.abs(hash) % 360;
 45 |     return `hsl(${h}, 60%, 85%)`;
 46 |   }
 47 | </script>
 48 | 
 49 | <div class="board-view">
 50 |   <div class="board-columns">
 51 |     {#each groupValues as groupValue}
 52 |       <div class="board-column">
 53 |         <div class="column-header" style="background-color: {getGroupColor(groupValue)}">
 54 |           <h3>{groupValue}</h3>
 55 |           <span class="count">{groupedFiles[groupValue].length}</span>
 56 |         </div>
 57 |         <div class="column-cards">
 58 |           {#each groupedFiles[groupValue] as file}
 59 |             <div class="card">
 60 |               <h4>{getPropertyValue(file, titleField)}</h4>
 61 |               {#if descriptionField}
 62 |                 <p class="description">{getPropertyValue(file, descriptionField)}</p>
 63 |               {/if}
 64 |               <div class="card-meta">
 65 |                 {#if file.tags && file.tags.length}
 66 |                   <div class="tags">
 67 |                     {#each file.tags.slice(0, 3) as tag}
 68 |                       <span class="tag">{tag}</span>
 69 |                     {/each}
 70 |                   </div>
 71 |                 {/if}
 72 |                 {#if file.priority}
 73 |                   <div class="priority priority-{file.priority}">
 74 |                     {file.priority}
 75 |                   </div>
 76 |                 {/if}
 77 |               </div>
 78 |             </div>
 79 |           {/each}
 80 |         </div>
 81 |       </div>
 82 |     {/each}
 83 |   </div>
 84 | </div>
 85 | 
 86 | <style>
 87 |   .board-view {
 88 |     width: 100%;
 89 |     height: 100%;
 90 |     overflow-x: auto;
 91 |   }
 92 |   
 93 |   .board-columns {
 94 |     display: flex;
 95 |     padding: 10px;
 96 |     gap: 12px;
 97 |     min-height: 400px;
 98 |   }
 99 |   
100 |   .board-column {
101 |     flex: 0 0 280px;
102 |     display: flex;
103 |     flex-direction: column;
104 |     border-radius: 6px;
105 |     background: #f5f5f5;
106 |     max-height: 100%;
107 |   }
108 |   
109 |   .column-header {
110 |     padding: 10px 15px;
111 |     border-radius: 6px 6px 0 0;
112 |     display: flex;
113 |     justify-content: space-between;
114 |     align-items: center;
115 |     font-weight: 500;
116 |   }
117 |   
118 |   .column-header h3 {
119 |     margin: 0;
120 |     font-size: 16px;
121 |   }
122 |   
123 |   .count {
124 |     background: rgba(255, 255, 255, 0.5);
125 |     border-radius: 12px;
126 |     padding: 2px 8px;
127 |     font-size: 12px;
128 |   }
129 |   
130 |   .column-cards {
131 |     padding: 10px;
132 |     overflow-y: auto;
133 |     flex-grow: 1;
134 |   }
135 |   
136 |   .card {
137 |     background: white;
138 |     border-radius: 6px;
139 |     padding: 10px;
140 |     margin-bottom: 10px;
141 |     box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
142 |   }
143 |   
144 |   .card h4 {
145 |     margin: 0 0 8px 0;
146 |     font-size: 14px;
147 |     line-height: 1.3;
148 |   }
149 |   
150 |   .description {
151 |     font-size: 12px;
152 |     color: #666;
153 |     margin: 0 0 8px 0;
154 |     line-height: 1.4;
155 |     display: -webkit-box;
156 |     -webkit-box-orient: vertical;
157 |     -webkit-line-clamp: 2;
158 |     overflow: hidden;
159 |   }
160 |   
161 |   .card-meta {
162 |     display: flex;
163 |     justify-content: space-between;
164 |     font-size: 12px;
165 |   }
166 |   
167 |   .tags {
168 |     display: flex;
169 |     gap: 4px;
170 |     flex-wrap: wrap;
171 |   }
172 |   
173 |   .tag {
174 |     background: #eee;
175 |     padding: 2px 6px;
176 |     border-radius: 4px;
177 |     color: #666;
178 |     font-size: 11px;
179 |   }
180 |   
181 |   .priority {
182 |     width: 20px;
183 |     height: 20px;
184 |     border-radius: 50%;
185 |     display: flex;
186 |     align-items: center;
187 |     justify-content: center;
188 |     font-weight: bold;
189 |     color: white;
190 |   }
191 |   
192 |   .priority-1 { background-color: #c0c0c0; }
193 |   .priority-2 { background-color: #8bc9ff; }
194 |   .priority-3 { background-color: #ffcb66; }
195 |   .priority-4 { background-color: #ff9e66; }
196 |   .priority-5 { background-color: #ff6666; }
197 | </style> 


--------------------------------------------------------------------------------
/src/lib/GalleryView.svelte:
--------------------------------------------------------------------------------
  1 | <script lang="ts">
  2 |   import { getPropertyValue } from './basesParser';
  3 |   
  4 |   export let files: any[] = [];
  5 |   export let titleField: string = 'file.name';
  6 |   export let descriptionField: string = 'summary';
  7 |   export let coverField: string = ''; // Optional field for cover images
  8 |   export let limit: number = 50;
  9 |   
 10 |   function generateColorFromString(str: string): string {
 11 |     // Simple hash function to generate a color from a string
 12 |     const hash = str.split('').reduce((acc, char) => {
 13 |       return char.charCodeAt(0) + ((acc << 5) - acc);
 14 |     }, 0);
 15 |     
 16 |     const h = Math.abs(hash) % 360;
 17 |     return `hsl(${h}, 60%, 60%)`;
 18 |   }
 19 |   
 20 |   function getInitials(name: string): string {
 21 |     return name
 22 |       .split(/\s+/)
 23 |       .slice(0, 2)
 24 |       .map(word => word[0])
 25 |       .join('')
 26 |       .toUpperCase();
 27 |   }
 28 | </script>
 29 | 
 30 | <div class="gallery-view">
 31 |   <div class="gallery-grid">
 32 |     {#each files.slice(0, limit) as file}
 33 |       <div class="gallery-card">
 34 |         <div class="gallery-card-cover">
 35 |           {#if coverField && getPropertyValue(file, coverField)}
 36 |             <img src={getPropertyValue(file, coverField)} alt={getPropertyValue(file, titleField)} />
 37 |           {:else}
 38 |             <div 
 39 |               class="cover-placeholder" 
 40 |               style="background-color: {generateColorFromString(getPropertyValue(file, titleField))}"
 41 |             >
 42 |               <span>{getInitials(getPropertyValue(file, titleField))}</span>
 43 |             </div>
 44 |           {/if}
 45 |         </div>
 46 |         <div class="gallery-card-content">
 47 |           <h3 class="card-title">{getPropertyValue(file, titleField)}</h3>
 48 |           {#if file.author}
 49 |             <div class="card-author">{file.author}</div>
 50 |           {/if}
 51 |           {#if descriptionField && getPropertyValue(file, descriptionField)}
 52 |             <p class="card-description">{getPropertyValue(file, descriptionField)}</p>
 53 |           {/if}
 54 |           {#if file.tags && file.tags.length}
 55 |             <div class="card-tags">
 56 |               {#each file.tags.slice(0, 3) as tag}
 57 |                 <span class="tag">{tag}</span>
 58 |               {/each}
 59 |             </div>
 60 |           {/if}
 61 |           {#if file.readingProgress !== undefined}
 62 |             <div class="reading-progress">
 63 |               <div class="progress-bar">
 64 |                 <div class="progress-fill" style="width: {file.readingProgress}%"></div>
 65 |               </div>
 66 |               <span class="progress-text">{file.readingProgress}%</span>
 67 |             </div>
 68 |           {/if}
 69 |         </div>
 70 |       </div>
 71 |     {/each}
 72 |   </div>
 73 | </div>
 74 | 
 75 | <style>
 76 |   .gallery-view {
 77 |     width: 100%;
 78 |     padding: 10px;
 79 |     overflow-y: auto;
 80 |   }
 81 |   
 82 |   .gallery-grid {
 83 |     display: grid;
 84 |     grid-template-columns: repeat(auto-fill, minmax(220px, 1fr));
 85 |     gap: 20px;
 86 |   }
 87 |   
 88 |   .gallery-card {
 89 |     background: white;
 90 |     border-radius: 8px;
 91 |     overflow: hidden;
 92 |     box-shadow: 0 2px 6px rgba(0, 0, 0, 0.1);
 93 |     display: flex;
 94 |     flex-direction: column;
 95 |     transition: transform 0.2s ease, box-shadow 0.2s ease;
 96 |   }
 97 |   
 98 |   .gallery-card:hover {
 99 |     transform: translateY(-4px);
100 |     box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
101 |   }
102 |   
103 |   .gallery-card-cover {
104 |     height: 160px;
105 |     overflow: hidden;
106 |   }
107 |   
108 |   .gallery-card-cover img {
109 |     width: 100%;
110 |     height: 100%;
111 |     object-fit: cover;
112 |   }
113 |   
114 |   .cover-placeholder {
115 |     width: 100%;
116 |     height: 100%;
117 |     display: flex;
118 |     align-items: center;
119 |     justify-content: center;
120 |   }
121 |   
122 |   .cover-placeholder span {
123 |     font-size: 32px;
124 |     font-weight: bold;
125 |     color: white;
126 |   }
127 |   
128 |   .gallery-card-content {
129 |     padding: 15px;
130 |     flex-grow: 1;
131 |     display: flex;
132 |     flex-direction: column;
133 |   }
134 |   
135 |   .card-title {
136 |     margin: 0 0 5px 0;
137 |     font-size: 16px;
138 |     font-weight: 600;
139 |     line-height: 1.3;
140 |   }
141 |   
142 |   .card-author {
143 |     color: #666;
144 |     font-size: 14px;
145 |     margin-bottom: 10px;
146 |   }
147 |   
148 |   .card-description {
149 |     font-size: 14px;
150 |     color: #555;
151 |     margin: 0 0 10px 0;
152 |     line-height: 1.4;
153 |     display: -webkit-box;
154 |     -webkit-box-orient: vertical;
155 |     -webkit-line-clamp: 3;
156 |     overflow: hidden;
157 |     flex-grow: 1;
158 |   }
159 |   
160 |   .card-tags {
161 |     display: flex;
162 |     flex-wrap: wrap;
163 |     gap: 5px;
164 |     margin-top: 5px;
165 |   }
166 |   
167 |   .tag {
168 |     background: #f0f0f0;
169 |     padding: 2px 8px;
170 |     border-radius: 4px;
171 |     font-size: 12px;
172 |     color: #666;
173 |   }
174 |   
175 |   .reading-progress {
176 |     margin-top: 10px;
177 |     display: flex;
178 |     align-items: center;
179 |     gap: 10px;
180 |   }
181 |   
182 |   .progress-bar {
183 |     flex-grow: 1;
184 |     height: 6px;
185 |     background: #eee;
186 |     border-radius: 3px;
187 |     overflow: hidden;
188 |   }
189 |   
190 |   .progress-fill {
191 |     height: 100%;
192 |     background: #50567a;
193 |   }
194 |   
195 |   .progress-text {
196 |     font-size: 12px;
197 |     color: #666;
198 |     min-width: 40px;
199 |     text-align: right;
200 |   }
201 | </style> 


--------------------------------------------------------------------------------
/src/lib/mockDataGeneratorLazy.ts:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Lazy-loaded mock data generator to reduce initial bundle size
  3 |  */
  4 | 
  5 | export interface MockFile {
  6 |   file: {
  7 |     file: string;
  8 |     name: string;
  9 |     ctime: Date;
 10 |     mtime: Date;
 11 |     ext: string;
 12 |     size: number;
 13 |     folder: string;
 14 |     path: string;
 15 |     tags: string[];
 16 |     links: string[];
 17 |   };
 18 |   status: string;
 19 |   priority: number;
 20 |   tags: string[];
 21 |   price: number;
 22 |   age: number;
 23 |   has_coords: boolean;
 24 |   lat: number;
 25 |   long: number;
 26 |   author: string;
 27 |   created: Date;
 28 |   summary: string;
 29 |   wordCount: number;
 30 |   category: string;
 31 |   [key: string]: any;
 32 | }
 33 | 
 34 | let fakerInstance: any = null;
 35 | 
 36 | async function getFaker() {
 37 |   if (!fakerInstance) {
 38 |     const { faker } = await import('@faker-js/faker');
 39 |     fakerInstance = faker;
 40 |   }
 41 |   return fakerInstance;
 42 | }
 43 | 
 44 | /**
 45 |  * Generate mock files with realistic data using Faker.js
 46 |  */
 47 | export async function generateMockFiles(count: number = 20): Promise<MockFile[]> {
 48 |   const faker = await getFaker();
 49 |   
 50 |   const statuses = ["Todo", "In Progress", "Done", "Cancelled"];
 51 |   const extensions = [".md", ".txt", ".pdf", ".docx"];
 52 | 
 53 |   return Array.from({ length: count }, (_, index): MockFile => {
 54 |     const ext = extensions[Math.floor(Math.random() * extensions.length)];
 55 |     const tags = Array.from(
 56 |       { length: Math.floor(Math.random() * 4) + 1 },
 57 |       () => faker.lorem.word()
 58 |     );
 59 | 
 60 |     // Random links
 61 |     const possibleLinks = ["Home", "Projects", "Books", "Reading", "Textbook"];
 62 |     const links = Array.from(
 63 |       { length: Math.floor(Math.random() * 3) },
 64 |       () => possibleLinks[Math.floor(Math.random() * possibleLinks.length)]
 65 |     );
 66 | 
 67 |     // Base file properties
 68 |     const fileName = faker.system.fileName().replace(/\.[^/.]+$/, "") + ".md";
 69 | 
 70 |     return {
 71 |       file: {
 72 |         file: `file_${index}`,
 73 |         name: fileName,
 74 |         ctime: faker.date.past(),
 75 |         mtime: faker.date.recent(),
 76 |         ext,
 77 |         size: faker.number.int({ min: 1024, max: 1024 * 1024 * 10 }),
 78 |         folder: faker.system.directoryPath(),
 79 |         path: faker.system.filePath().replace(/\.[^/.]+$/, ext),
 80 |         tags,
 81 |         links,
 82 |       },
 83 |       status: statuses[Math.floor(Math.random() * statuses.length)],
 84 |       priority: faker.number.int({ min: 1, max: 5 }),
 85 |       tags,
 86 |       price: faker.number.float({ min: 0, max: 1000, fractionDigits: 2 }),
 87 |       age: faker.number.int({ min: 1, max: 100 }),
 88 |       has_coords: Math.random() > 0.7,
 89 |       lat: faker.location.latitude(),
 90 |       long: faker.location.longitude(),
 91 |       author: faker.person.fullName(),
 92 |       created: faker.date.past(),
 93 |       summary: faker.lorem.paragraph(),
 94 |       wordCount: faker.number.int({ min: 100, max: 10000 }),
 95 |       category: ["Reference", "Project", "Daily Note", "Meeting"][
 96 |         Math.floor(Math.random() * 4)
 97 |       ],
 98 |     };
 99 |   });
100 | }
101 | 
102 | /**
103 |  * Generate book-specific mock data
104 |  */
105 | export async function generateBookData(count: number = 10): Promise<MockFile[]> {
106 |   const faker = await getFaker();
107 |   
108 |   const bookStatuses = ["Todo", "In Progress", "Done"];
109 |   const bookGenres = ["Fiction", "Non-Fiction", "Biography", "History", "Science", "Technology"];
110 | 
111 |   return Array.from({ length: count }, (_, i): MockFile => {
112 |     const status = bookStatuses[Math.floor(Math.random() * bookStatuses.length)];
113 |     const genre = bookGenres[Math.floor(Math.random() * bookGenres.length)];
114 |     const wordCount = faker.number.int({ min: 20000, max: 150000 });
115 |     const readingProgress = status === "Done" ? 100 : Math.floor(Math.random() * 100);
116 | 
117 |     const tags = [
118 |       "book",
119 |       genre.toLowerCase(),
120 |       ...(Math.random() > 0.5 ? ["favorite"] : []),
121 |     ];
122 | 
123 |     // Some books should link to Textbook for our filter to work
124 |     const links = ["Books", "Reading"];
125 |     if (Math.random() > 0.5) {
126 |       links.push("Textbook");
127 |     }
128 | 
129 |     return {
130 |       file: {
131 |         file: `book_${i}`,
132 |         name: faker.lorem.words(3) + ".md",
133 |         ctime: faker.date.past(),
134 |         mtime: faker.date.recent(),
135 |         ext: ".md",
136 |         size: faker.number.int({ min: 5000, max: 50000 }),
137 |         folder: "/Books",
138 |         path: `/Books/${faker.lorem.words(3)}.md`,
139 |         tags,
140 |         links,
141 |       },
142 |       status,
143 |       priority: faker.number.int({ min: 1, max: 5 }),
144 |       tags,
145 |       price: faker.number.float({ min: 10, max: 50, fractionDigits: 2 }),
146 |       age: faker.number.int({ min: 1, max: 10 }),
147 |       has_coords: false,
148 |       lat: 0,
149 |       long: 0,
150 |       author: faker.person.fullName(),
151 |       created: faker.date.past(),
152 |       summary: faker.lorem.paragraph(),
153 |       wordCount,
154 |       category: "Book",
155 |       genre,
156 |       readingProgress,
157 |       rating: faker.number.int({ min: 1, max: 5 }),
158 |       dateStarted: faker.date.past(),
159 |     };
160 |   });
161 | }
162 | 
163 | /**
164 |  * Generate a specific number of files with known properties for demonstrations
165 |  */
166 | export async function generateDemoFiles(): Promise<MockFile[]> {
167 |   const baseFiles = await generateMockFiles(15);
168 |   const bookFiles = await generateBookData(15);
169 | 
170 |   return [...baseFiles, ...bookFiles];
171 | }
172 | 


--------------------------------------------------------------------------------
/src/lib/templateExamples.ts:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Collection of example Base templates to demonstrate different features
  3 |  */
  4 | 
  5 | export const baseTemplates = {
  6 |   basic: {
  7 |     name: "Basic Table",
  8 |     yaml: `filters:
  9 |   or:
 10 |     - taggedWith(file.file, "book")
 11 |     - and:
 12 |         - taggedWith(file.file, "book")
 13 |         - linksTo(file.file, "Textbook")
 14 | formulas:
 15 |   formatted_price: 'concat(price, " dollars")'
 16 |   ppu: "price / age"
 17 | display:
 18 |   status: Status
 19 |   formula.formatted_price: "Price"
 20 |   "file.ext": Extension
 21 | views:
 22 |   - type: table
 23 |     name: "My table"
 24 |     limit: 10
 25 |     filters:
 26 |       and:
 27 |         - 'status != "done"'
 28 |         - or:
 29 |             - "formula.ppu > 5"
 30 |             - "price > 2.1"
 31 |     order:
 32 |       - file.name
 33 |       - file.ext
 34 |       - property.age
 35 |       - formula.ppu
 36 |       - formula.formatted_price`,
 37 |   },
 38 | 
 39 |   bookLibrary: {
 40 |     name: "Book Library",
 41 |     yaml: `filters:
 42 |   and:
 43 |     - taggedWith(file.file, "book")
 44 |     - not:
 45 |         - taggedWith(file.file, "textbook")
 46 | formulas:
 47 |   read_status: 'if(status == "Done", "Read", "Unread")'
 48 |   reading_time: 'wordCount / 250'
 49 | display:
 50 |   author: Author
 51 |   formula.read_status: "Reading Status"
 52 |   formula.reading_time: "Est. Reading Hours"
 53 |   tags: Tags
 54 |   priority: Priority
 55 | views:
 56 |   - type: table
 57 |     name: "Reading List"
 58 |     filters: 'formula.read_status == "Unread"'
 59 |     order:
 60 |       - file.name
 61 |       - author
 62 |       - priority
 63 |       - formula.reading_time
 64 |   - type: gallery
 65 |     name: "Book Gallery"
 66 |     filters: 'formula.read_status == "Unread"'
 67 |     title_field: file.name
 68 |     description_field: summary
 69 |   - type: board
 70 |     name: "Reading Board"
 71 |     group_by: "priority"
 72 |     title_field: file.name
 73 |     description_field: summary
 74 |   - type: table
 75 |     name: "Completed Books"
 76 |     filters: 'formula.read_status == "Read"'
 77 |     order:
 78 |       - file.name
 79 |       - author
 80 |       - priority
 81 |       - formula.reading_time`,
 82 |   },
 83 | 
 84 |   projectTracker: {
 85 |     name: "Project Tracker",
 86 |     yaml: `filters:
 87 |   and:
 88 |     - taggedWith(file.file, "project")
 89 | formulas:
 90 |   days_active: 'if(status == "In Progress", date_diff(now(), created) / 86400000, 0)'
 91 |   status_emoji: 'if(status == "Done", "✅", if(status == "In Progress", "🔄", if(status == "Backlog", "📌", "❓")))'
 92 | display:
 93 |   formula.status_emoji: ""
 94 |   status: Status
 95 |   priority: Priority
 96 |   category: Category
 97 |   formula.days_active: "Days Active"
 98 | views:
 99 |   - type: board
100 |     name: "Project Board"
101 |     group_by: "status"
102 |     title_field: file.name
103 |     description_field: summary
104 |   - type: table
105 |     name: "Active Projects"
106 |     filters: 'status == "In Progress"'
107 |     order:
108 |       - priority
109 |       - file.name
110 |       - formula.days_active
111 |   - type: table
112 |     name: "Backlog"
113 |     filters: 'status == "Backlog"'
114 |     order:
115 |       - priority
116 |       - file.name`,
117 |   },
118 | 
119 |   locationTracker: {
120 |     name: "Location Tracker",
121 |     yaml: `filters:
122 |   and:
123 |     - has_coords == true
124 | formulas:
125 |   location_name: 'concat(file.name, " (", lat, ", ", long, ")")'
126 | display:
127 |   formula.location_name: "Location"
128 |   summary: "Description"
129 |   category: "Category"
130 | views:
131 |   - type: map
132 |     name: "All Locations"
133 |     lat: lat
134 |     long: long
135 |     title: file.name
136 |   - type: table
137 |     name: "Location Details"
138 |     order:
139 |       - formula.location_name
140 |       - category
141 |       - summary`,
142 |   },
143 | 
144 |   taskManagement: {
145 |     name: "Task Management",
146 |     yaml: `filters:
147 |   or:
148 |     - category == "Project"
149 |     - taggedWith(file.file, "task")
150 | formulas:
151 |   due_soon: 'if(created > dateModify(now(), "-7 days"), true, false)'
152 |   priority_label: 'if(priority == 5, "Critical", if(priority == 4, "High", if(priority == 3, "Medium", if(priority == 2, "Low", "None"))))'
153 | display:
154 |   status: "Status"
155 |   formula.priority_label: "Priority"
156 |   author: "Assigned To"
157 |   formula.due_soon: "Due Soon"
158 | views:
159 |   - type: board
160 |     name: "Task Board"
161 |     group_by: "status"
162 |     title_field: file.name
163 |     description_field: summary
164 |   - type: table
165 |     name: "All Tasks"
166 |     group_by: "status"
167 |     order:
168 |       - formula.priority_label
169 |       - file.name
170 |       - author
171 |   - type: calendar
172 |     name: "Task Calendar"
173 |     date_field: created
174 |     title_field: file.name
175 |   - type: table
176 |     name: "Due Soon"
177 |     filters: 'formula.due_soon == true'
178 |     order:
179 |       - formula.priority_label
180 |       - status
181 |       - file.name`,
182 |   },
183 | 
184 |   readingPlanner: {
185 |     name: "Reading Planner",
186 |     yaml: `filters:
187 |   taggedWith(file.file, "book")
188 | formulas:
189 |   read_percentage: 'readingProgress'
190 |   time_to_finish: 'if(readingProgress < 100, wordCount * (100 - readingProgress) / 100 / 250, 0)'
191 |   read_status: 'if(readingProgress == 100, "Finished", if(readingProgress > 0, "In Progress", "Not Started"))'
192 |   star_rating: 'if(rating == 5, "★★★★★", if(rating == 4, "★★★★☆", if(rating == 3, "★★★☆☆", if(rating == 2, "★★☆☆☆", if(rating == 1, "★☆☆☆☆", "Not rated")))))'
193 | display:
194 |   author: "Author"
195 |   genre: "Genre"
196 |   readingProgress: "Progress"
197 |   formula.read_status: "Status"
198 |   formula.time_to_finish: "Hours Left"
199 |   formula.star_rating: "Rating"
200 | views:
201 |   - type: gallery
202 |     name: "Book Collection"
203 |     title_field: file.name
204 |     description_field: summary
205 |   - type: board
206 |     name: "Reading Status"
207 |     group_by: "formula.read_status"
208 |     title_field: file.name
209 |     description_field: summary
210 |   - type: table
211 |     name: "Reading List"
212 |     filters: 'readingProgress < 100'
213 |     order:
214 |       - readingProgress
215 |       - author
216 |       - genre
217 |   - type: table
218 |     name: "Finished Books"
219 |     filters: 'readingProgress == 100'
220 |     order:
221 |       - rating
222 |       - author
223 |       - genre
224 |   - type: calendar
225 |     name: "Reading Timeline"
226 |     date_field: dateStarted
227 |     title_field: file.name`,
228 |   },
229 | };
230 | 


--------------------------------------------------------------------------------
/src/dataview-parser/normalize.ts:
--------------------------------------------------------------------------------
  1 | import emojiRegex from "emoji-regex";
  2 | import P from "parsimmon";
  3 | 
  4 | /** The Obsidian 'link', used for uniquely describing a file, header, or block. */
  5 | export class Link {
  6 |   /** The file path this link points to. */
  7 |   public path!: string;
  8 |   /** The display name associated with the link. */
  9 |   public display?: string;
 10 |   /** The block ID or header this link points to within a file, if relevant. */
 11 |   public subpath?: string;
 12 |   /** Is this link an embedded link (!)? */
 13 |   public embed!: boolean;
 14 |   /** The type of this link, which determines what 'subpath' refers to, if anything. */
 15 |   public type!: "file" | "header" | "block";
 16 | 
 17 |   /** Create a link to a specific file. */
 18 |   public static file(path: string, embed: boolean = false, display?: string) {
 19 |     return new Link({
 20 |       path,
 21 |       embed,
 22 |       display,
 23 |       subpath: undefined,
 24 |       type: "file",
 25 |     });
 26 |   }
 27 | 
 28 |   public static infer(
 29 |     linkpath: string,
 30 |     embed: boolean = false,
 31 |     display?: string
 32 |   ) {
 33 |     if (linkpath.includes("#^")) {
 34 |       let split = linkpath.split("#^");
 35 |       return Link.block(split[0], split[1], embed, display);
 36 |     } else if (linkpath.includes("#")) {
 37 |       let split = linkpath.split("#");
 38 |       return Link.header(split[0], split[1], embed, display);
 39 |     } else return Link.file(linkpath, embed, display);
 40 |   }
 41 | 
 42 |   /** Create a link to a specific file and header in that file. */
 43 |   public static header(
 44 |     path: string,
 45 |     header: string,
 46 |     embed?: boolean,
 47 |     display?: string
 48 |   ) {
 49 |     // Headers need to be normalized to alpha-numeric & with extra spacing removed.
 50 |     return new Link({
 51 |       path,
 52 |       embed,
 53 |       display,
 54 |       subpath: normalizeHeaderForLink(header),
 55 |       type: "header",
 56 |     });
 57 |   }
 58 | 
 59 |   /** Create a link to a specific file and block in that file. */
 60 |   public static block(
 61 |     path: string,
 62 |     blockId: string,
 63 |     embed?: boolean,
 64 |     display?: string
 65 |   ) {
 66 |     return new Link({
 67 |       path,
 68 |       embed,
 69 |       display,
 70 |       subpath: blockId,
 71 |       type: "block",
 72 |     });
 73 |   }
 74 | 
 75 |   public static fromObject(object: Record<string, any>) {
 76 |     return new Link(object);
 77 |   }
 78 | 
 79 |   private constructor(fields: Partial<Link>) {
 80 |     Object.assign(this, fields);
 81 |   }
 82 | 
 83 |   /** Checks for link equality (i.e., that the links are pointing to the same exact location). */
 84 |   public equals(other: Link): boolean {
 85 |     if (other == undefined || other == null) return false;
 86 | 
 87 |     return (
 88 |       this.path == other.path &&
 89 |       this.type == other.type &&
 90 |       this.subpath == other.subpath
 91 |     );
 92 |   }
 93 | 
 94 |   /** Convert this link to it's markdown representation. */
 95 |   public toString(): string {
 96 |     return this.markdown();
 97 |   }
 98 | 
 99 |   /** Convert this link to a raw object which is serialization-friendly. */
100 |   public toObject(): Record<string, any> {
101 |     return {
102 |       path: this.path,
103 |       type: this.type,
104 |       subpath: this.subpath,
105 |       display: this.display,
106 |       embed: this.embed,
107 |     };
108 |   }
109 | 
110 |   /** Update this link with a new path. */
111 |   //@ts-ignore; error appeared after updating Obsidian to 0.15.4; it also updated other packages but didn't say which
112 |   public withPath(path: string) {
113 |     return new Link(Object.assign({}, this, { path }));
114 |   }
115 | 
116 |   /** Return a new link which points to the same location but with a new display value. */
117 |   public withDisplay(display?: string) {
118 |     return new Link(Object.assign({}, this, { display }));
119 |   }
120 | 
121 |   /** Convert a file link into a link to a specific header. */
122 |   public withHeader(header: string) {
123 |     return Link.header(this.path, header, this.embed, this.display);
124 |   }
125 | 
126 |   /** Convert any link into a link to its file. */
127 |   public toFile() {
128 |     return Link.file(this.path, this.embed, this.display);
129 |   }
130 | 
131 |   /** Convert this link into an embedded link. */
132 |   public toEmbed(): Link {
133 |     if (this.embed) {
134 |       return this;
135 |     } else {
136 |       let link = new Link(this);
137 |       link.embed = true;
138 |       return link;
139 |     }
140 |   }
141 | 
142 |   /** Convert this link into a non-embedded link. */
143 |   public fromEmbed(): Link {
144 |     if (!this.embed) {
145 |       return this;
146 |     } else {
147 |       let link = new Link(this);
148 |       link.embed = false;
149 |       return link;
150 |     }
151 |   }
152 | 
153 |   /** Convert this link to markdown so it can be rendered. */
154 |   public markdown(): string {
155 |     let result = (this.embed ? "!" : "") + "[[" + this.obsidianLink();
156 | 
157 |     if (this.display) {
158 |       result += "|" + this.display;
159 |     } else {
160 |       result += "|" + getFileTitle(this.path);
161 |       if (this.type == "header" || this.type == "block")
162 |         result += " > " + this.subpath;
163 |     }
164 | 
165 |     result += "]]";
166 |     return result;
167 |   }
168 | 
169 |   /** Convert the inner part of the link to something that Obsidian can open / understand. */
170 |   public obsidianLink(): string {
171 |     const escaped = this.path.replaceAll("|", "\\|");
172 |     if (this.type == "header")
173 |       return escaped + "#" + this.subpath?.replaceAll("|", "\\|");
174 |     if (this.type == "block")
175 |       return escaped + "#^" + this.subpath?.replaceAll("|", "\\|");
176 |     else return escaped;
177 |   }
178 | 
179 |   /** The stripped name of the file this link points to. */
180 |   public fileName(): string {
181 |     return getFileTitle(this.path).replace(".md", "");
182 |   }
183 | }
184 | 
185 | /** Get the "title" for a file, by stripping other parts of the path as well as the extension. */
186 | export function getFileTitle(path: string): string {
187 |   if (path.includes("/")) path = path.substring(path.lastIndexOf("/") + 1);
188 |   if (path.endsWith(".md")) path = path.substring(0, path.length - 3);
189 |   return path;
190 | }
191 | 
192 | const HEADER_CANONICALIZER: P.Parser<string> = P.alt(
193 |   P.regex(new RegExp(emojiRegex(), "")),
194 |   P.regex(/[0-9\p{Letter}_-]+/u),
195 |   P.whitespace.map((_) => " "),
196 |   P.any.map((_) => " ")
197 | )
198 |   .many()
199 |   .map((result) => {
200 |     return result.join("").split(/\s+/).join(" ").trim();
201 |   });
202 | 
203 | export function normalizeHeaderForLink(header: string): string {
204 |   return HEADER_CANONICALIZER.tryParse(header);
205 | }
206 | 


--------------------------------------------------------------------------------
/src/dataview-parser/query-types.ts:
--------------------------------------------------------------------------------
  1 | /** Provides an AST for complex queries. */
  2 | import type { Source } from "./source-types";
  3 | import type { Field } from "./field";
  4 | 
  5 | /** The supported query types (corresponding to view types). */
  6 | export type QueryType = "list" | "table" | "task" | "calendar";
  7 | 
  8 | /** A single-line comment. */
  9 | export type Comment = string;
 10 | 
 11 | /** Fields used in the query portion. */
 12 | export interface NamedField {
 13 |   /** The effective name of this field. */
 14 |   name: string;
 15 |   /** The value of this field. */
 16 |   field: Field;
 17 | }
 18 | 
 19 | /** A query sort by field, for determining sort order. */
 20 | export interface QuerySortBy {
 21 |   /** The field to sort on. */
 22 |   field: Field;
 23 |   /** The direction to sort in. */
 24 |   direction: "ascending" | "descending";
 25 | }
 26 | 
 27 | /** Utility functions for quickly creating fields. */
 28 | export namespace QueryFields {
 29 |   export function named(name: string, field: Field): NamedField {
 30 |     return { name, field } as NamedField;
 31 |   }
 32 | 
 33 |   export function sortBy(
 34 |     field: Field,
 35 |     dir: "ascending" | "descending"
 36 |   ): QuerySortBy {
 37 |     return { field, direction: dir };
 38 |   }
 39 | }
 40 | 
 41 | //////////////////////
 42 | // Query Definition //
 43 | //////////////////////
 44 | 
 45 | /** A query which should render a list of elements. */
 46 | export interface ListQuery {
 47 |   type: "list";
 48 |   /** What should be rendered in the list. */
 49 |   format?: Field;
 50 |   /** If true, show the default DI field; otherwise, don't. */
 51 |   showId: boolean;
 52 | }
 53 | 
 54 | /** A query which renders a table of elements. */
 55 | export interface TableQuery {
 56 |   type: "table";
 57 |   /** The fields (computed or otherwise) to select. */
 58 |   fields: NamedField[];
 59 |   /** If true, show the default ID field; otherwise, don't. */
 60 |   showId: boolean;
 61 | }
 62 | 
 63 | /** A query which renders a collection of tasks. */
 64 | export interface TaskQuery {
 65 |   type: "task";
 66 | }
 67 | 
 68 | /** A query which renders a collection of notes in a calendar view. */
 69 | export interface CalendarQuery {
 70 |   type: "calendar";
 71 |   /** The date field that we'll be grouping notes by for the calendar view */
 72 |   field: NamedField;
 73 | }
 74 | 
 75 | export type QueryHeader = ListQuery | TableQuery | TaskQuery | CalendarQuery;
 76 | 
 77 | /** A step which only retains rows whose 'clause' field is truthy. */
 78 | export interface WhereStep {
 79 |   type: "where";
 80 |   clause: Field;
 81 | }
 82 | 
 83 | /** A step which sorts all current rows by the given list of sorts. */
 84 | export interface SortByStep {
 85 |   type: "sort";
 86 |   fields: QuerySortBy[];
 87 | }
 88 | 
 89 | /** A step which truncates the number of rows to the given amount. */
 90 | export interface LimitStep {
 91 |   type: "limit";
 92 |   amount: Field;
 93 | }
 94 | 
 95 | /** A step which flattens rows into multiple child rows. */
 96 | export interface FlattenStep {
 97 |   type: "flatten";
 98 |   field: NamedField;
 99 | }
100 | 
101 | /** A step which groups rows into groups by the given field. */
102 | export interface GroupStep {
103 |   type: "group";
104 |   field: NamedField;
105 | }
106 | 
107 | /** A virtual step which extracts an array of values from each row. */
108 | export interface ExtractStep {
109 |   type: "extract";
110 |   fields: Record<string, Field>;
111 | }
112 | 
113 | export type QueryOperation =
114 |   | WhereStep
115 |   | SortByStep
116 |   | LimitStep
117 |   | FlattenStep
118 |   | GroupStep
119 |   | ExtractStep;
120 | 
121 | /**
122 |  * A query over the Obsidian database. Queries have a specific and deterministic execution order:
123 |  */
124 | export interface Query {
125 |   /** The view type to render this query in. */
126 |   header: QueryHeader;
127 |   /** The source that file candidates will come from. */
128 |   source: Source;
129 |   /** The operations to apply to the data to produce the final result that will be rendered. */
130 |   operations: QueryOperation[];
131 | }
132 | 
133 | /** Functional return type for error handling. */
134 | export class Success<T, E> {
135 |   public successful: true;
136 | 
137 |   public constructor(public value: T) {
138 |     this.successful = true;
139 |   }
140 | 
141 |   public map<U>(f: (a: T) => U): Result<U, E> {
142 |     return new Success(f(this.value));
143 |   }
144 | 
145 |   public flatMap<U>(f: (a: T) => Result<U, E>): Result<U, E> {
146 |     return f(this.value);
147 |   }
148 | 
149 |   public mapErr<U>(f: (e: E) => U): Result<T, U> {
150 |     return this as any as Result<T, U>;
151 |   }
152 | 
153 |   public bimap<T2, E2>(
154 |     succ: (a: T) => T2,
155 |     _fail: (b: E) => E2
156 |   ): Result<T2, E2> {
157 |     return this.map(succ) as any;
158 |   }
159 | 
160 |   public orElse(_value: T): T {
161 |     return this.value;
162 |   }
163 | 
164 |   public cast<U>(): Result<U, E> {
165 |     return this as any;
166 |   }
167 | 
168 |   public orElseThrow(_message?: (e: E) => string): T {
169 |     return this.value;
170 |   }
171 | }
172 | 
173 | /** Functional return type for error handling. */
174 | export class Failure<T, E> {
175 |   public successful: false;
176 | 
177 |   public constructor(public error: E) {
178 |     this.successful = false;
179 |   }
180 | 
181 |   public map<U>(_f: (a: T) => U): Result<U, E> {
182 |     return this as any as Failure<U, E>;
183 |   }
184 | 
185 |   public flatMap<U>(_f: (a: T) => Result<U, E>): Result<U, E> {
186 |     return this as any as Failure<U, E>;
187 |   }
188 | 
189 |   public mapErr<U>(f: (e: E) => U): Result<T, U> {
190 |     return new Failure(f(this.error));
191 |   }
192 | 
193 |   public bimap<T2, E2>(
194 |     _succ: (a: T) => T2,
195 |     fail: (b: E) => E2
196 |   ): Result<T2, E2> {
197 |     return this.mapErr(fail) as any;
198 |   }
199 | 
200 |   public orElse(value: T): T {
201 |     return value;
202 |   }
203 | 
204 |   public cast<U>(): Result<U, E> {
205 |     return this as any;
206 |   }
207 | 
208 |   public orElseThrow(message?: (e: E) => string): T {
209 |     if (message) throw new Error(message(this.error));
210 |     else throw new Error("" + this.error);
211 |   }
212 | }
213 | 
214 | export type Result<T, E> = Success<T, E> | Failure<T, E>;
215 | 
216 | /** Monadic 'Result' type which encapsulates whether a procedure succeeded or failed, as well as it's return value. */
217 | export namespace Result {
218 |   /** Construct a new success result wrapping the given value. */
219 |   export function success<T, E>(value: T): Result<T, E> {
220 |     return new Success(value);
221 |   }
222 | 
223 |   /** Construct a new failure value wrapping the given error. */
224 |   export function failure<T, E>(error: E): Result<T, E> {
225 |     return new Failure(error);
226 |   }
227 | 
228 |   /** Join two results with a bi-function and return a new result. */
229 |   export function flatMap2<T1, T2, O, E>(
230 |     first: Result<T1, E>,
231 |     second: Result<T2, E>,
232 |     f: (a: T1, b: T2) => Result<O, E>
233 |   ): Result<O, E> {
234 |     if (first.successful) {
235 |       if (second.successful) return f(first.value, second.value);
236 |       else return failure(second.error);
237 |     } else {
238 |       return failure(first.error);
239 |     }
240 |   }
241 | 
242 |   /** Join two results with a bi-function and return a new result. */
243 |   export function map2<T1, T2, O, E>(
244 |     first: Result<T1, E>,
245 |     second: Result<T2, E>,
246 |     f: (a: T1, b: T2) => O
247 |   ): Result<O, E> {
248 |     return flatMap2(first, second, (a, b) => success(f(a, b)));
249 |   }
250 | }
251 | 


--------------------------------------------------------------------------------
/src/lib/CalendarView.svelte:
--------------------------------------------------------------------------------
  1 | <script lang="ts">
  2 |   import { getPropertyValue } from './basesParser';
  3 |   
  4 |   export let files: any[] = [];
  5 |   export let dateField: string = 'created';  // Field containing date
  6 |   export let titleField: string = 'file.name';
  7 |   export let descriptionField: string = 'summary';
  8 |   
  9 |   // Current date values
 10 |   let currentDate = new Date();
 11 |   let currentYear = currentDate.getFullYear();
 12 |   let currentMonth = currentDate.getMonth();
 13 |   
 14 |   // Date navigation
 15 |   function prevMonth() {
 16 |     if (currentMonth === 0) {
 17 |       currentMonth = 11;
 18 |       currentYear--;
 19 |     } else {
 20 |       currentMonth--;
 21 |     }
 22 |   }
 23 |   
 24 |   function nextMonth() {
 25 |     if (currentMonth === 11) {
 26 |       currentMonth = 0;
 27 |       currentYear++;
 28 |     } else {
 29 |       currentMonth++;
 30 |     }
 31 |   }
 32 |   
 33 |   function resetToToday() {
 34 |     const today = new Date();
 35 |     currentYear = today.getFullYear();
 36 |     currentMonth = today.getMonth();
 37 |   }
 38 |   
 39 |   // Generate the calendar days
 40 |   $: calendarDays = generateCalendarDays(currentYear, currentMonth);
 41 |   $: monthName = new Date(currentYear, currentMonth, 1).toLocaleString('default', { month: 'long' });
 42 |   
 43 |   function generateCalendarDays(year: number, month: number) {
 44 |     const firstDay = new Date(year, month, 1);
 45 |     const lastDay = new Date(year, month + 1, 0);
 46 |     const daysInMonth = lastDay.getDate();
 47 |     
 48 |     // Get the day of the week for the first day (0 = Sunday, 6 = Saturday)
 49 |     const startingDayOfWeek = firstDay.getDay();
 50 |     
 51 |     // Generate days from previous month to fill the first week
 52 |     const prevMonthDays = [];
 53 |     if (startingDayOfWeek > 0) {
 54 |       const prevMonthLastDay = new Date(year, month, 0).getDate();
 55 |       for (let i = prevMonthLastDay - startingDayOfWeek + 1; i <= prevMonthLastDay; i++) {
 56 |         prevMonthDays.push({
 57 |           date: new Date(year, month - 1, i),
 58 |           day: i,
 59 |           isCurrentMonth: false
 60 |         });
 61 |       }
 62 |     }
 63 |     
 64 |     // Generate days for current month
 65 |     const currentMonthDays = [];
 66 |     for (let i = 1; i <= daysInMonth; i++) {
 67 |       currentMonthDays.push({
 68 |         date: new Date(year, month, i),
 69 |         day: i,
 70 |         isCurrentMonth: true
 71 |       });
 72 |     }
 73 |     
 74 |     // Generate days for next month to fill the last week
 75 |     const nextMonthDays = [];
 76 |     const totalDaysSoFar = prevMonthDays.length + currentMonthDays.length;
 77 |     const remainingCells = 42 - totalDaysSoFar; // 6 rows x 7 days
 78 |     
 79 |     for (let i = 1; i <= remainingCells; i++) {
 80 |       nextMonthDays.push({
 81 |         date: new Date(year, month + 1, i),
 82 |         day: i,
 83 |         isCurrentMonth: false
 84 |       });
 85 |     }
 86 |     
 87 |     return [...prevMonthDays, ...currentMonthDays, ...nextMonthDays];
 88 |   }
 89 |   
 90 |   // Filter files for each day
 91 |   function getFilesForDate(date: Date) {
 92 |     const startOfDay = new Date(date);
 93 |     startOfDay.setHours(0, 0, 0, 0);
 94 |     
 95 |     const endOfDay = new Date(date);
 96 |     endOfDay.setHours(23, 59, 59, 999);
 97 |     
 98 |     return files.filter(file => {
 99 |       const fileDate = new Date(getPropertyValue(file, dateField));
100 |       return fileDate >= startOfDay && fileDate <= endOfDay;
101 |     });
102 |   }
103 |   
104 |   // Determine if a day has files
105 |   function hasFilesForDate(date: Date) {
106 |     return getFilesForDate(date).length > 0;
107 |   }
108 |   
109 |   // Get first 3 files for a date (for display in calendar)
110 |   function getDisplayFilesForDate(date: Date) {
111 |     return getFilesForDate(date).slice(0, 3);
112 |   }
113 |   
114 |   // Day name headers
115 |   const dayNames = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
116 | </script>
117 | 
118 | <div class="calendar-view">
119 |   <div class="calendar-header">
120 |     <div class="month-nav">
121 |       <button on:click={prevMonth}>←</button>
122 |       <h3>{monthName} {currentYear}</h3>
123 |       <button on:click={nextMonth}>→</button>
124 |     </div>
125 |     <button class="today-button" on:click={resetToToday}>Today</button>
126 |   </div>
127 |   
128 |   <div class="calendar-grid">
129 |     <div class="calendar-days-header">
130 |       {#each dayNames as day}
131 |         <div class="day-name">{day}</div>
132 |       {/each}
133 |     </div>
134 |     
135 |     <div class="calendar-days">
136 |       {#each calendarDays as { date, day, isCurrentMonth }, i}
137 |         <div class="day-cell {isCurrentMonth ? 'current-month' : 'other-month'}">
138 |           <div class="day-number">{day}</div>
139 |           {#if hasFilesForDate(date)}
140 |             <div class="day-events">
141 |               {#each getDisplayFilesForDate(date) as file}
142 |                 <div class="event">
143 |                   <span class="event-title">{getPropertyValue(file, titleField)}</span>
144 |                 </div>
145 |               {/each}
146 |               
147 |               {#if getFilesForDate(date).length > 3}
148 |                 <div class="more-events">+{getFilesForDate(date).length - 3} more</div>
149 |               {/if}
150 |             </div>
151 |           {/if}
152 |         </div>
153 |       {/each}
154 |     </div>
155 |   </div>
156 | </div>
157 | 
158 | <style>
159 |   .calendar-view {
160 |     width: 100%;
161 |     height: 100%;
162 |     display: flex;
163 |     flex-direction: column;
164 |   }
165 |   
166 |   .calendar-header {
167 |     display: flex;
168 |     justify-content: space-between;
169 |     align-items: center;
170 |     padding: 10px;
171 |     background: #f5f5f5;
172 |     border-radius: 6px 6px 0 0;
173 |   }
174 |   
175 |   .month-nav {
176 |     display: flex;
177 |     align-items: center;
178 |     gap: 10px;
179 |   }
180 |   
181 |   .month-nav button {
182 |     background: white;
183 |     border: 1px solid #ddd;
184 |     border-radius: 4px;
185 |     width: 30px;
186 |     height: 30px;
187 |     font-size: 16px;
188 |     cursor: pointer;
189 |     display: flex;
190 |     align-items: center;
191 |     justify-content: center;
192 |   }
193 |   
194 |   .month-nav h3 {
195 |     margin: 0;
196 |     font-size: 16px;
197 |     min-width: 150px;
198 |     text-align: center;
199 |   }
200 |   
201 |   .today-button {
202 |     background: #50567a;
203 |     color: white;
204 |     border: none;
205 |     padding: 5px 10px;
206 |     border-radius: 4px;
207 |     cursor: pointer;
208 |   }
209 |   
210 |   .calendar-grid {
211 |     flex-grow: 1;
212 |     display: flex;
213 |     flex-direction: column;
214 |     border: 1px solid #eee;
215 |     border-radius: 0 0 6px 6px;
216 |   }
217 |   
218 |   .calendar-days-header {
219 |     display: grid;
220 |     grid-template-columns: repeat(7, 1fr);
221 |     background: #f9f9f9;
222 |     border-bottom: 1px solid #eee;
223 |   }
224 |   
225 |   .day-name {
226 |     padding: 10px;
227 |     text-align: center;
228 |     font-weight: 500;
229 |     font-size: 14px;
230 |     color: #666;
231 |   }
232 |   
233 |   .calendar-days {
234 |     display: grid;
235 |     grid-template-columns: repeat(7, 1fr);
236 |     grid-template-rows: repeat(6, 1fr);
237 |     flex-grow: 1;
238 |   }
239 |   
240 |   .day-cell {
241 |     border-right: 1px solid #eee;
242 |     border-bottom: 1px solid #eee;
243 |     padding: 5px;
244 |     min-height: 80px;
245 |     display: flex;
246 |     flex-direction: column;
247 |   }
248 |   
249 |   .day-cell:nth-child(7n) {
250 |     border-right: none;
251 |   }
252 |   
253 |   .day-cell.other-month {
254 |     background: #f9f9f9;
255 |     color: #aaa;
256 |   }
257 |   
258 |   .day-number {
259 |     font-size: 14px;
260 |     font-weight: 500;
261 |     margin-bottom: 5px;
262 |   }
263 |   
264 |   .day-events {
265 |     display: flex;
266 |     flex-direction: column;
267 |     gap: 3px;
268 |     font-size: 12px;
269 |   }
270 |   
271 |   .event {
272 |     background: #e9efff;
273 |     border-left: 3px solid #50567a;
274 |     padding: 3px 5px;
275 |     border-radius: 2px;
276 |     white-space: nowrap;
277 |     overflow: hidden;
278 |     text-overflow: ellipsis;
279 |   }
280 |   
281 |   .event-title {
282 |     font-size: 11px;
283 |   }
284 |   
285 |   .more-events {
286 |     font-size: 11px;
287 |     color: #666;
288 |     text-align: center;
289 |     margin-top: 2px;
290 |   }
291 | </style> 


--------------------------------------------------------------------------------
/src/dataview-parser/query-parse.ts:
--------------------------------------------------------------------------------
  1 | import { EXPRESSION } from "./expression-parse";
  2 | import P from "parsimmon";
  3 | import type {
  4 |   FlattenStep,
  5 |   GroupStep,
  6 |   LimitStep,
  7 |   NamedField,
  8 |   Query,
  9 |   QueryHeader,
 10 |   QueryOperation,
 11 |   QuerySortBy,
 12 |   QueryType,
 13 |   SortByStep,
 14 |   WhereStep,
 15 |   Comment,
 16 | } from "./query-types";
 17 | import { QueryFields } from "./query-types";
 18 | import type { Source } from "./source-types";
 19 | import { Sources } from "./source-types";
 20 | import { Result } from "./query-types";
 21 | 
 22 | ///////////////////
 23 | // Query Parsing //
 24 | ///////////////////
 25 | 
 26 | /** Typings for the outputs of all of the parser combinators. */
 27 | interface QueryLanguageTypes {
 28 |   queryType: QueryType;
 29 |   comment: Comment;
 30 | 
 31 |   explicitNamedField: NamedField;
 32 |   namedField: NamedField;
 33 |   sortField: QuerySortBy;
 34 | 
 35 |   // Entire clauses in queries.
 36 |   headerClause: QueryHeader;
 37 |   fromClause: Source;
 38 |   whereClause: WhereStep;
 39 |   sortByClause: SortByStep;
 40 |   limitClause: LimitStep;
 41 |   flattenClause: FlattenStep;
 42 |   groupByClause: GroupStep;
 43 |   clause: QueryOperation;
 44 |   query: Query;
 45 | }
 46 | 
 47 | /** Return a new parser which executes the underlying parser and returns it's raw string representation. */
 48 | export function captureRaw<T>(base: P.Parser<T>): P.Parser<[T, string]> {
 49 |   return P.custom((success, failure) => {
 50 |     return (input, i) => {
 51 |       let result = (base as any)._(input, i);
 52 |       if (!result.status) return result;
 53 | 
 54 |       return Object.assign({}, result, {
 55 |         value: [result.value, input.substring(i, result.index)],
 56 |       });
 57 |     };
 58 |   });
 59 | }
 60 | 
 61 | /** Strip newlines and excess whitespace out of text. */
 62 | function stripNewlines(text: string): string {
 63 |   return text
 64 |     .split(/[\r\n]+/)
 65 |     .map((t) => t.trim())
 66 |     .join("");
 67 | }
 68 | 
 69 | /** Given `parser`, return the parser that returns `if_eof()` if EOF is found,
 70 |  * otherwise `parser` preceded by (non-optional) whitespace */
 71 | function precededByWhitespaceIfNotEof<T>(
 72 |   if_eof: (_: undefined) => T,
 73 |   parser: P.Parser<T>
 74 | ): P.Parser<T> {
 75 |   return P.eof.map(if_eof).or(P.whitespace.then(parser));
 76 | }
 77 | 
 78 | /** A parsimmon-powered parser-combinator implementation of the query language. */
 79 | export const QUERY_LANGUAGE = P.createLanguage<QueryLanguageTypes>({
 80 |   // Simple atom parsing, like words, identifiers, numbers.
 81 |   queryType: (q) =>
 82 |     P.alt<string>(P.regexp(/TABLE|LIST|TASK|CALENDAR/i))
 83 |       .map((str) => str.toLowerCase() as QueryType)
 84 |       .desc("query type ('TABLE', 'LIST', 'TASK', or 'CALENDAR')"),
 85 |   explicitNamedField: (q) =>
 86 |     P.seqMap(
 87 |       EXPRESSION.field.skip(P.whitespace),
 88 |       P.regexp(/AS/i).skip(P.whitespace),
 89 |       EXPRESSION.identifier.or(EXPRESSION.string),
 90 |       (field, _as, ident) => QueryFields.named(ident, field)
 91 |     ),
 92 |   comment: () =>
 93 |     P.Parser((input, i) => {
 94 |       // Parse a comment, which is a line starting with //.
 95 |       let line = input.substring(i);
 96 |       if (!line.startsWith("//")) return P.makeFailure(i, "Not a comment");
 97 |       // The comment ends at the end of the line.
 98 |       line = line.split("\n")[0];
 99 |       let comment = line.substring(2).trim();
100 |       return P.makeSuccess(i + line.length, comment);
101 |     }),
102 |   namedField: (q) =>
103 |     P.alt<NamedField>(
104 |       q.explicitNamedField,
105 |       captureRaw(EXPRESSION.field).map(([value, text]) =>
106 |         QueryFields.named(stripNewlines(text), value)
107 |       )
108 |     ),
109 |   sortField: (q) =>
110 |     P.seqMap(
111 |       EXPRESSION.field.skip(P.optWhitespace),
112 |       P.regexp(/ASCENDING|DESCENDING|ASC|DESC/i).atMost(1),
113 |       (field, dir) => {
114 |         let direction = dir.length == 0 ? "ascending" : dir[0].toLowerCase();
115 |         if (direction == "desc") direction = "descending";
116 |         if (direction == "asc") direction = "ascending";
117 |         return {
118 |           field: field,
119 |           direction: direction as "ascending" | "descending",
120 |         };
121 |       }
122 |     ),
123 | 
124 |   headerClause: (q) =>
125 |     q.queryType
126 |       .chain((type): P.Parser<QueryHeader> => {
127 |         switch (type) {
128 |           case "table": {
129 |             return precededByWhitespaceIfNotEof(
130 |               () => ({ type, fields: [], showId: true }),
131 |               P.seqMap(
132 |                 P.regexp(/WITHOUT\s+ID/i)
133 |                   .skip(P.optWhitespace)
134 |                   .atMost(1),
135 |                 P.sepBy(q.namedField, P.string(",").trim(P.optWhitespace)),
136 |                 (withoutId, fields) => {
137 |                   return { type, fields, showId: withoutId.length == 0 };
138 |                 }
139 |               )
140 |             );
141 |           }
142 |           case "list":
143 |             return precededByWhitespaceIfNotEof(
144 |               () => ({ type, format: undefined, showId: true }),
145 |               P.seqMap(
146 |                 P.regexp(/WITHOUT\s+ID/i)
147 |                   .skip(P.optWhitespace)
148 |                   .atMost(1),
149 |                 EXPRESSION.field.atMost(1),
150 |                 (withoutId, format) => {
151 |                   return {
152 |                     type,
153 |                     format: format.length == 1 ? format[0] : undefined,
154 |                     showId: withoutId.length == 0,
155 |                   };
156 |                 }
157 |               )
158 |             );
159 |           case "task":
160 |             return P.succeed({ type });
161 |           case "calendar":
162 |             return P.whitespace.then(
163 |               P.seqMap(q.namedField, (field) => {
164 |                 return {
165 |                   type,
166 |                   showId: true,
167 |                   field,
168 |                 } as QueryHeader;
169 |               })
170 |             );
171 |           default:
172 |             return P.fail(`Unrecognized query type '${type}'`);
173 |         }
174 |       })
175 |       .desc("TABLE or LIST or TASK or CALENDAR"),
176 |   fromClause: (q) =>
177 |     P.seqMap(
178 |       P.regexp(/FROM/i),
179 |       P.whitespace,
180 |       EXPRESSION.source,
181 |       (_1, _2, source) => source
182 |     ),
183 |   whereClause: (q) =>
184 |     P.seqMap(
185 |       P.regexp(/WHERE/i),
186 |       P.whitespace,
187 |       EXPRESSION.field,
188 |       (where, _, field) => {
189 |         return { type: "where", clause: field } as WhereStep;
190 |       }
191 |     ).desc("WHERE <expression>"),
192 |   sortByClause: (q) =>
193 |     P.seqMap(
194 |       P.regexp(/SORT/i),
195 |       P.whitespace,
196 |       q.sortField.sepBy1(P.string(",").trim(P.optWhitespace)),
197 |       (sort, _1, fields) => {
198 |         return { type: "sort", fields } as SortByStep;
199 |       }
200 |     ).desc("SORT field [ASC/DESC]"),
201 |   limitClause: (q) =>
202 |     P.seqMap(
203 |       P.regexp(/LIMIT/i),
204 |       P.whitespace,
205 |       EXPRESSION.field,
206 |       (limit, _1, field) => {
207 |         return { type: "limit", amount: field } as LimitStep;
208 |       }
209 |     ).desc("LIMIT <value>"),
210 |   flattenClause: (q) =>
211 |     P.seqMap(
212 |       P.regexp(/FLATTEN/i).skip(P.whitespace),
213 |       q.namedField,
214 |       (_, field) => {
215 |         return { type: "flatten", field } as FlattenStep;
216 |       }
217 |     ).desc("FLATTEN <value> [AS <name>]"),
218 |   groupByClause: (q) =>
219 |     P.seqMap(
220 |       P.regexp(/GROUP BY/i).skip(P.whitespace),
221 |       q.namedField,
222 |       (_, field) => {
223 |         return { type: "group", field } as GroupStep;
224 |       }
225 |     ).desc("GROUP BY <value> [AS <name>]"),
226 |   // Full query parsing.
227 |   clause: (q) =>
228 |     P.alt(
229 |       q.fromClause,
230 |       q.whereClause,
231 |       q.sortByClause,
232 |       q.limitClause,
233 |       q.groupByClause,
234 |       q.flattenClause
235 |     ),
236 |   query: (q) =>
237 |     P.seqMap(
238 |       q.headerClause.trim(optionalWhitespaceOrComment),
239 |       q.fromClause.trim(optionalWhitespaceOrComment).atMost(1),
240 |       q.clause.trim(optionalWhitespaceOrComment).many(),
241 |       (header, from, clauses) => {
242 |         return {
243 |           header,
244 |           source: from.length == 0 ? Sources.folder("") : from[0],
245 |           operations: clauses,
246 |         } as Query;
247 |       }
248 |     ),
249 | });
250 | 
251 | /**
252 |  * A parser for optional whitespace or comments. This is used to exclude whitespace and comments from other parsers.
253 |  */
254 | const optionalWhitespaceOrComment: P.Parser<string> = P.alt(
255 |   P.whitespace,
256 |   QUERY_LANGUAGE.comment
257 | )
258 |   .many() // Use many() since there may be zero whitespaces or comments.
259 |   // Transform the many to a single result.
260 |   .map((arr) => arr.join(""));
261 | 
262 | /**
263 |  * Attempt to parse a query from the given query text, returning a string error
264 |  * if the parse failed.
265 |  */
266 | export function parseQuery(text: string): Result<Query, string> {
267 |   try {
268 |     let query = QUERY_LANGUAGE.query.tryParse(text);
269 |     return Result.success(query);
270 |   } catch (error) {
271 |     return Result.failure("" + error);
272 |   }
273 | }
274 | 


--------------------------------------------------------------------------------
/src/lib/mockDataGenerator.ts:
--------------------------------------------------------------------------------
  1 | import { faker } from "@faker-js/faker";
  2 | 
  3 | export interface MockFile {
  4 |   file: {
  5 |     file: string;
  6 |     name: string;
  7 |     ctime: Date;
  8 |     mtime: Date;
  9 |     ext: string;
 10 |     size: number;
 11 |     folder: string;
 12 |     path: string;
 13 |     tags?: string[];
 14 |     links?: string[];
 15 |   };
 16 |   [key: string]: any;
 17 | }
 18 | 
 19 | /**
 20 |  * Generate mock files with properties that might be found in Obsidian notes
 21 |  */
 22 | export function generateMockFiles(count: number = 100): MockFile[] {
 23 |   return Array.from({ length: count }, (_, i) => generateMockFile(i));
 24 | }
 25 | 
 26 | /**
 27 |  * Generate a single mock file with properties
 28 |  */
 29 | function generateMockFile(index: number): MockFile {
 30 |   // Common file statuses in task management
 31 |   const statuses = ["TODO", "In Progress", "Done", "Backlog", "Waiting"];
 32 | 
 33 |   // Only use markdown files
 34 |   const ext = ".md";
 35 | 
 36 |   // Random tags that might be used in notes
 37 |   const possibleTags = [
 38 |     "book",
 39 |     "article",
 40 |     "blog",
 41 |     "research",
 42 |     "project",
 43 |     "idea",
 44 |     "meeting",
 45 |     "review",
 46 |     "personal",
 47 |     "work",
 48 |     "study",
 49 |     "reference",
 50 |     "tag",
 51 |     "important",
 52 |     "urgent",
 53 |     "later",
 54 |     "textbook",
 55 |   ];
 56 | 
 57 |   // Random list of tags
 58 |   const tags = Array.from(
 59 |     { length: Math.floor(Math.random() * 5) },
 60 |     () => possibleTags[Math.floor(Math.random() * possibleTags.length)]
 61 |   );
 62 | 
 63 |   // Random links
 64 |   const possibleLinks = ["Home", "Projects", "Books", "Reading", "Textbook"];
 65 |   const links = Array.from(
 66 |     { length: Math.floor(Math.random() * 3) },
 67 |     () => possibleLinks[Math.floor(Math.random() * possibleLinks.length)]
 68 |   );
 69 | 
 70 |   // Base file properties
 71 |   const fileName = faker.system.fileName().replace(/\.[^/.]+$/, "") + ".md";
 72 | 
 73 |   return {
 74 |     file: {
 75 |       file: `file_${index}`, // Placeholder for file object
 76 |       name: fileName,
 77 |       ctime: faker.date.past(),
 78 |       mtime: faker.date.recent(),
 79 |       ext,
 80 |       size: faker.number.int({ min: 1024, max: 1024 * 1024 * 10 }),
 81 |       folder: faker.system.directoryPath(),
 82 |       path: faker.system.filePath().replace(/\.[^/.]+$/, ext),
 83 |       tags,
 84 |       links,
 85 |     },
 86 |     status: statuses[Math.floor(Math.random() * statuses.length)],
 87 |     priority: faker.number.int({ min: 1, max: 5 }),
 88 |     tags,
 89 |     price: faker.number.float({ min: 0, max: 1000, fractionDigits: 2 }),
 90 |     age: faker.number.int({ min: 1, max: 100 }),
 91 |     has_coords: Math.random() > 0.7,
 92 |     lat: faker.location.latitude(),
 93 |     long: faker.location.longitude(),
 94 |     author: faker.person.fullName(),
 95 |     created: faker.date.past(),
 96 |     summary: faker.lorem.paragraph(),
 97 |     wordCount: faker.number.int({ min: 100, max: 10000 }),
 98 |     category: ["Reference", "Project", "Daily Note", "Meeting"][
 99 |       Math.floor(Math.random() * 4)
100 |     ],
101 |   };
102 | }
103 | 
104 | /**
105 |  * Generate book data for reading list and completed books
106 |  */
107 | function generateBookData(count: number): MockFile[] {
108 |   const bookStatuses = ["TODO", "In Progress", "Done"];
109 |   const bookGenres = [
110 |     "Fiction",
111 |     "Non-Fiction",
112 |     "Science Fiction",
113 |     "Fantasy",
114 |     "Biography",
115 |     "History",
116 |     "Self-Help",
117 |     "Business",
118 |     "Technology",
119 |   ];
120 | 
121 |   return Array.from({ length: count }, (_, i): MockFile => {
122 |     const status =
123 |       bookStatuses[Math.floor(Math.random() * bookStatuses.length)];
124 |     const genre = bookGenres[Math.floor(Math.random() * bookGenres.length)];
125 |     const wordCount = faker.number.int({ min: 20000, max: 150000 });
126 |     const readingProgress =
127 |       status === "Done" ? 100 : Math.floor(Math.random() * 100);
128 | 
129 |     const tags = [
130 |       "book",
131 |       genre.toLowerCase(),
132 |       ...(Math.random() > 0.5 ? ["favorite"] : []),
133 |     ];
134 | 
135 |     // Some books should link to Textbook for our filter to work
136 |     const links = ["Books", "Reading"];
137 |     if (Math.random() > 0.5) {
138 |       links.push("Textbook");
139 |     }
140 | 
141 |     return {
142 |       file: {
143 |         file: `book_${i}`,
144 |         name: `${faker.word.adjective()} ${faker.word.noun()} - ${faker.person.lastName()}`,
145 |         ctime: faker.date.past(),
146 |         mtime: faker.date.recent(),
147 |         ext: ".md",
148 |         size: faker.number.int({ min: 5000, max: 15000 }),
149 |         folder: "/Reading/Books",
150 |         path: `/Reading/Books/book_${i}.md`,
151 |         tags,
152 |         links,
153 |       },
154 |       status,
155 |       priority: faker.number.int({ min: 1, max: 5 }),
156 |       price: faker.number.float({ min: 0, max: 100, fractionDigits: 2 }),
157 |       age: faker.number.int({ min: 1, max: 100 }),
158 |       tags,
159 |       author: faker.person.fullName(),
160 |       created: faker.date.past(),
161 |       summary: faker.lorem.paragraph(),
162 |       wordCount,
163 |       category: "Reference",
164 |       isbn: faker.string.numeric(13),
165 |       genre,
166 |       publicationYear: faker.number.int({ min: 1950, max: 2023 }),
167 |       publisher: faker.company.name(),
168 |       readingProgress,
169 |       rating: status === "Done" ? faker.number.int({ min: 1, max: 5 }) : null,
170 |       dateStarted: faker.date.past(),
171 |       dateFinished: status === "Done" ? faker.date.recent() : null,
172 |     };
173 |   });
174 | }
175 | 
176 | /**
177 |  * Generate a specific number of files with known properties for specific demonstrations
178 |  */
179 | export function generateDemoFiles(): MockFile[] {
180 |   const baseFiles = generateMockFiles(15);
181 |   const bookFiles = generateBookData(15);
182 | 
183 |   // Create base data for formula evaluation
184 |   const baseData = {
185 |     formulas: {
186 |       read_status: 'if(status == "Done", "Read", "Unread")',
187 |       reading_time: "wordCount / 250",
188 |       ppu: "price / age",
189 |     },
190 |   };
191 | 
192 |   // Add specific files with properties for demonstrating filters
193 |   const specialFiles = [
194 |     {
195 |       file: {
196 |         file: "special_1",
197 |         name: "1984 by George Orwell",
198 |         ctime: new Date("2023-01-15"),
199 |         mtime: new Date("2023-03-20"),
200 |         ext: ".md",
201 |         size: 15460,
202 |         folder: "/Reading/Books",
203 |         path: "/Reading/Books/1984.md",
204 |         tags: ["book", "fiction", "classic", "dystopian"],
205 |         links: ["Books", "Classics", "Textbook"],
206 |       },
207 |       status: "Done",
208 |       priority: 5,
209 |       tags: ["book", "fiction", "classic", "dystopian"],
210 |       author: "George Orwell",
211 |       created: new Date("2023-01-15"),
212 |       summary:
213 |         "Classic dystopian novel about a society under totalitarian rule",
214 |       wordCount: 88000,
215 |       category: "Reference",
216 |       isbn: "9780451524935",
217 |       genre: "Fiction",
218 |       publicationYear: 1949,
219 |       publisher: "Penguin Books",
220 |       readingProgress: 100,
221 |       rating: 5,
222 |       dateStarted: new Date("2023-01-20"),
223 |       dateFinished: new Date("2023-02-15"),
224 |       _baseData: baseData,
225 |     },
226 |     {
227 |       file: {
228 |         file: "special_2",
229 |         name: "The Hobbit by J.R.R. Tolkien",
230 |         ctime: new Date("2023-04-10"),
231 |         mtime: new Date("2023-05-10"),
232 |         ext: ".md",
233 |         size: 12240,
234 |         folder: "/Reading/Books",
235 |         path: "/Reading/Books/The_Hobbit.md",
236 |         tags: ["book", "fiction", "fantasy"],
237 |         links: ["Books", "Textbook", "Fantasy"],
238 |       },
239 |       status: "In Progress",
240 |       priority: 4,
241 |       tags: ["book", "fiction", "fantasy"],
242 |       author: "J.R.R. Tolkien",
243 |       created: new Date("2023-04-10"),
244 |       summary:
245 |         "Fantasy novel about Bilbo Baggins' adventure with dwarves to reclaim their treasure",
246 |       wordCount: 95000,
247 |       category: "Reference",
248 |       isbn: "9780547928227",
249 |       genre: "Fantasy",
250 |       publicationYear: 1937,
251 |       publisher: "Houghton Mifflin",
252 |       readingProgress: 65,
253 |       rating: null,
254 |       dateStarted: new Date("2023-04-15"),
255 |       dateFinished: null,
256 |       _baseData: baseData,
257 |     },
258 |     {
259 |       file: {
260 |         file: "special_3",
261 |         name: "Project Alpha Planning",
262 |         ctime: new Date("2023-05-10"),
263 |         mtime: new Date("2023-05-10"),
264 |         ext: ".md",
265 |         size: 8240,
266 |         folder: "/Projects/Alpha",
267 |         path: "/Projects/Alpha/Planning.md",
268 |         tags: ["project", "planning", "important", "tag"],
269 |         links: ["Projects", "Alpha", "Team"],
270 |       },
271 |       status: "In Progress",
272 |       priority: 4,
273 |       tags: ["project", "planning", "important"],
274 |       price: 0,
275 |       age: 2,
276 |       has_coords: true,
277 |       lat: 40.7128,
278 |       long: -74.006,
279 |       author: "Team Lead",
280 |       created: new Date("2023-05-10"),
281 |       summary: "Project planning document for Alpha",
282 |       wordCount: 4500,
283 |       category: "Project",
284 |       _baseData: baseData,
285 |     },
286 |     {
287 |       file: {
288 |         file: "special_4",
289 |         name: "Meeting Notes - Research Review",
290 |         ctime: new Date("2023-06-22"),
291 |         mtime: new Date("2023-06-22"),
292 |         ext: ".md",
293 |         size: 5130,
294 |         folder: "/Meetings",
295 |         path: "/Meetings/Research_Review.md",
296 |         tags: ["meeting", "research", "notes", "tag"],
297 |         links: ["Meetings", "Research"],
298 |       },
299 |       status: "Done",
300 |       priority: 3,
301 |       tags: ["meeting", "research", "notes"],
302 |       price: 0,
303 |       age: 1,
304 |       has_coords: true,
305 |       lat: 37.7749,
306 |       long: -122.4194,
307 |       author: "Meeting Scribe",
308 |       created: new Date("2023-06-22"),
309 |       summary: "Notes from the research review meeting",
310 |       wordCount: 2200,
311 |       category: "Meeting",
312 |       _baseData: baseData,
313 |     },
314 |   ];
315 | 
316 |   // Add _baseData to all files
317 |   const allFiles = [...specialFiles, ...bookFiles, ...baseFiles].map((file) => {
318 |     return { ...file, _baseData: baseData };
319 |   });
320 | 
321 |   return allFiles;
322 | }
323 | 


--------------------------------------------------------------------------------
/docs/functions.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | permalink: bases/functions
  3 | ---
  4 | Functions are used in [[Introduction to Bases|Bases]] to manipulate data from [[Properties]] in filters and formulas. See the [[Bases syntax|bases syntax]] reference to learn more about how you can use functions.
  5 | 
  6 | Aside from [[Functions#Global|Global]] functions, most functions depend on the type of value you want to modify:
  7 | 
  8 | - [[Functions#Any|Any]]
  9 | - [[Functions#Date|Date]]
 10 | - [[Functions#String|String]]
 11 | - [[Functions#Number|Number]]
 12 | - [[Functions#List|List]]
 13 | - [[Functions#Link|Link]]
 14 | - [[Functions#File|File]]
 15 | - [[Functions#Object|Object]]
 16 | - [[Functions#Regular expression|Regular expression]]
 17 | 
 18 | ## Global
 19 | 
 20 | Global functions are used without a type.
 21 | 
 22 | ### `date()`
 23 | 
 24 | `date(date: string): date`
 25 | 
 26 | - `date(string): date` parses the provided string and returns a date object.
 27 | - The `date` string should be in the format `YYYY-MM-DD HH:mm:ss`.
 28 | 
 29 | ### `if()`
 30 | 
 31 | `if(condition: any, trueResult: any, falseResult?: any): any`
 32 | 
 33 | - `condition` is the condition to be evaluated.
 34 | - `trueResult` is the output if condition is true.
 35 | - `falseResult` is the optional output if the condition is false. If it is not given, then it is assumed to be `null`.
 36 | - Returns the `trueResult` if `condition` is true, or is a truthy value, or `falseResult` otherwise.
 37 | - Example: `if(isModified, "Modified", "Unmodified")`
 38 | 
 39 | ### `max()`
 40 | 
 41 | `max(value1: number, value2: number...): number`
 42 | 
 43 | - Returns the largest of all the provided numbers.
 44 | 
 45 | ### `min()`
 46 | 
 47 | `min(value1: number, value2: number...): number`
 48 | 
 49 | - Returns the smallest of all the provided numbers.
 50 | 
 51 | ### `link()`
 52 | 
 53 | `link(path: string | file, display?: string): Link`
 54 | 
 55 | - Parses a string `path` and returns a Link object that renders as a link to the path given.
 56 | - Optionally provide the `display` parameter to change what text the link says.
 57 | 
 58 | ### `list()`
 59 | 
 60 | `list(element: any): List`
 61 | 
 62 | - If the provided element is a list, return it unmodified.
 63 | - Otherwise, wraps the provided `element` in a list, creating a list with a single element.
 64 | - This function can be helpful when a property contains a mixture of strings or lists across the vault.
 65 | - Example: `list("value")` returns `["value"]`.
 66 | 
 67 | ### `now()`
 68 | 
 69 | `now(): date`
 70 | 
 71 | - `now()` returns a date object representing the current moment.
 72 | 
 73 | ### `number()`
 74 | 
 75 | `number(input: any): number`
 76 | 
 77 | - Attempt to return the provided value as a number.
 78 | - Date objects will be returned as milliseconds since the unix epoch.
 79 | - Booleans will return a 1 or 0.
 80 | - Strings will be parsed into a number and return an error if the result is invalid.
 81 | - Example, `number("3.4")` returns `3.4`.
 82 | 
 83 | ### `today()`
 84 | 
 85 | `today(): date`
 86 | 
 87 | - `today()` returns a date object representing the current date. The time portion is set to zero.
 88 | 
 89 | ## Any
 90 | 
 91 | Functions you can use with any value. This includes strings (e.g. `"hello"`), numbers (e.g. `42`), lists (e.g. `[1,2,3]`), objects, and more.
 92 | 
 93 | ### `toString()`
 94 | 
 95 | `any.toString(): string`
 96 | 
 97 | - Returns the string representation of any value.
 98 | - Example: `123.toString()` returns `"123"`.
 99 | 
100 | 
101 | ## Date
102 | 
103 | Functions you can use with a date and time such as `date("2025-05-27")`. Date comparisons can be done using [[Bases syntax#Date arithmetic|date arithmetic]].
104 | 
105 | ### Fields
106 | 
107 | The following fields are available for dates:
108 | 
109 | | Field              | Type     | Description                  |
110 | | ------------------ | -------- | ---------------------------- |
111 | | `date.year`        | `number` | The year of the date         |
112 | | `date.month`       | `number` | The month of the date (1–12) |
113 | | `date.day`         | `number` | The day of the month         |
114 | | `date.hour`        | `number` | The hour (0–23)              |
115 | | `date.minute`      | `number` | The minute (0–59)            |
116 | | `date.second`      | `number` | The second (0–59)            |
117 | | `date.millisecond` | `number` | The millisecond (0–999)      |
118 | 
119 | ### `date()`
120 | 
121 | `date.date(): date`
122 | 
123 | - Returns a date object with the time removed.
124 | - Example: `now().date().format("YYYY-MM-DD HH:mm:ss"` returns a string such as "2025-12-31 00:00:00"
125 | 
126 | ### `format()`
127 | 
128 | `date.format(format: string): string`
129 | 
130 | - `format` is the format string (e.g., `"YYYY-MM-DD"`).
131 | - Returns the date formatted as specified by a Moment.js format string.
132 | - Example: `date.format("YYYY-MM-DD")` returns `"2025-05-27"`.
133 | 
134 | ### `time()`
135 | 
136 | `date.time(): string`
137 | 
138 | - Returns the time
139 | - Example: `now().time()` returns a string such as "23:59:59"
140 | 
141 | ## String
142 | 
143 | Functions you can use with a sequence of characters such as `"hello".`
144 | 
145 | ### Fields
146 | 
147 | | Field           | Type     | Description                            |
148 | | --------------- | -------- | -------------------------------------- |
149 | | `string.length` | `number` | The number of characters in the string |
150 | 
151 | ### `contains()`
152 | 
153 | `string.contains(value: string): boolean`
154 | 
155 | - `value` is the substring to search for.
156 | - Returns true if the string contains `value`.
157 | - Example: `"hello".contains("ell")` returns `true`.
158 | 
159 | ### `containsAll()`
160 | 
161 | `string.containsAll(...values: string): boolean`
162 | 
163 | - `values` are one or more substrings to search for.
164 | - Returns true if the string contains all of the `values`.
165 | - Example: `"hello".containsAll("h", "e")` returns `true`.
166 | 
167 | ### `containsAny()`
168 | 
169 | `string.containsAny(...values: string): boolean`
170 | 
171 | - `values` are one or more substrings to search for.
172 | - Returns true if the string contains at least one of the `values`.
173 | - Example: `"hello".containsAny("x", "y", "e")` returns `true`.
174 | 
175 | ### `endsWith()`
176 | 
177 | `string.endsWith(query: string): boolean`
178 | 
179 | - `query` is the string to check at the end.
180 | - Returns true if this string ends with `query`.
181 | - Example: `"hello".endsWith("lo")` returns `true`.
182 | 
183 | ### `icon()`
184 | 
185 | `string.icon(): string`
186 | 
187 | - Returns a string that represents the icon name to be rendered using Lucide. The icon name must match a supported Lucide icon.
188 | - Example: `"arrow-right".icon()` returns `"arrow-right"`.
189 | 
190 | ### `isEmpty()`
191 | 
192 | `string.isEmpty(): boolean`
193 | 
194 | - Returns true if the string has no characters, or is not present.
195 | - Example: `"Hello world".isEmpty()` returns `false`.
196 | - Example: `"".isEmpty()` returns `true`.
197 | 
198 | ### `replace()`
199 | 
200 | `string.replace(pattern: string | Regexp, replacement: string): string`
201 | 
202 | - `pattern` is the value to search for in the target string.
203 | - `replacement` is the value to replace found patterns with.
204 | - If `pattern` is a string, all occurrences of the pattern will be replaced.
205 | - If `pattern` is a Regexp, the `g` flag determines if only the first or if all occurrences are replaced.
206 | - Example: `"a,b,c,d".replace(/,/, "-")` returns `"a-b,c,d"`, where as `"a,b,c,d".replace(/,/g, "-")` returns `"a-b-c-d"`.
207 | 
208 | ### `lower()`
209 | 
210 | `string.lower(): string`
211 | 
212 | - Returns the string converted to lower case.
213 | 
214 | ### `reverse()`
215 | 
216 | `string.reverse(): string`
217 | 
218 | - Reverses the string.
219 | - Example: `"hello".reverse()` returns `"olleh"`.
220 | 
221 | ### `slice()`
222 | 
223 | `string.slice(start: number, end?: number): string`
224 | 
225 | - `start` is the inclusive start index.
226 | - `end` is the optional exclusive end index.
227 | - Returns a substring from `start` (inclusive) to `end` (exclusive).
228 | - Example: `"hello".slice(1, 4)` returns `"ell"`.
229 | - If `end` is omitted, slices to the end of the string.
230 | 
231 | ### `split()`
232 | 
233 | `string.split(separator: string | Regexp, n?: number): list`
234 | 
235 | - `separator` is the delimiter for splitting the string.
236 | - `n` is an optional number. If provided, the result will have the first `n` elements.
237 | - Returns an list of substrings.
238 | - Example: `"a,b,c,d".split(",", 3)` or `"a,b,c,d".split(/,/, 3)` returns `["a", "b", "c"]`.
239 | 
240 | ### `startsWith()`
241 | 
242 | `string.startsWith(query: string): boolean`
243 | 
244 | - `query` is the string to check at the beginning.
245 | - Returns true if this string starts with `query`.
246 | - Example: `"hello".startsWith("he")` returns `true`.
247 | 
248 | ### `title()`
249 | 
250 | `string.title(): string`
251 | 
252 | - Converts the string to title case (first letter of each word capitalized).
253 | - Example: `"hello world".title()` returns `"Hello World"`.
254 | 
255 | ### `trim()`
256 | 
257 | `string.trim(): string`
258 | 
259 | - Removes whitespace from both ends of the string.
260 | - Example: `"  hi  ".trim()` returns `"hi"`.
261 | 
262 | ## Number
263 | 
264 | Functions you can use with numeric values such as `42`, `3.14`.
265 | 
266 | ### `abs()`
267 | 
268 | `number.abs(): number`
269 | 
270 | - Returns the absolute value of the number.
271 | - Example: `(-5).abs()` returns `5`.
272 | 
273 | ### `ceil()`
274 | 
275 | `number.ceil(): number`
276 | 
277 | - Rounds the number up to the nearest integer.
278 | - Example: `(2.1).ceil()` returns `3`.
279 | 
280 | ### `floor()`
281 | 
282 | `number.floor(): number`
283 | 
284 | - Rounds the number down to the nearest integer.
285 | - Example: `(2.9).floor()` returns `2`.
286 | 
287 | ### `round()`
288 | 
289 | `number.round(digits: number): number`
290 | 
291 | - Rounds the number to the nearest integer.
292 | - Optionally, provided a `digits` parameter to round to that number of decimal digits.
293 | - Example: `(2.5).round()` returns `3`, and `(2.3333).round(2)` returns `2.33`.
294 | 
295 | ### `toFixed()`
296 | 
297 | `number.toFixed(precision: number): string`
298 | 
299 | - `precision` is the number of decimal places.
300 | - Returns a string with the number in fixed-point notation.
301 | - Example: `(3.14159).toFixed(2)` returns `"3.14"`.
302 | 
303 | ### `isEmpty()`
304 | 
305 | `number.isEmpty(): boolean`
306 | 
307 | - Returns true if the number is not present.
308 | - Example: `5.isEmpty()` returns `false`.
309 | 
310 | ## List
311 | 
312 | Functions you can use with an ordered list of elements such as `[1, 2, 3]`.
313 | 
314 | ### Fields
315 | 
316 | | Field         | Type     | Description                        |
317 | | ------------- | -------- | ---------------------------------- |
318 | | `list.length` | `number` | The number of elements in the list |
319 | 
320 | ### `contains()`
321 | 
322 | `list.contains(value: any): boolean`
323 | 
324 | - `value` is the element to search for.
325 | - Returns true if the list contains `value`.
326 | - Example: `[1,2,3].contains(2)` returns `true`.
327 | 
328 | ### `containsAll()`
329 | 
330 | `list.containsAll(...values: any): boolean`
331 | 
332 | - `values` are one or more elements to search for.
333 | - Returns true if the list contains all of the `values`.
334 | - Example: `[1,2,3].containsAll(2,3)` returns `true`.
335 | 
336 | ### `containsAny()`
337 | 
338 | `list.containsAny(...values: any): boolean`
339 | 
340 | - `values` are one or more elements to search for.
341 | - Returns true if the list contains at least one of the `values`.
342 | - Example: `[1,2,3].containsAny(3,4)` returns `true`.
343 | 
344 | ### `isEmpty()`
345 | 
346 | `list.isEmpty(): boolean`
347 | 
348 | - Returns true if the list has no elements.
349 | - Example: `[1,2,3].isEmpty()` returns `false`.
350 | 
351 | ### `join()`
352 | 
353 | `list.join(separator: string): string`
354 | 
355 | - `separator` is the string to insert between elements.
356 | - Joins all list elements into a single string.
357 | - Example: `[1,2,3].join(",")` returns `"1,2,3"`.
358 | 
359 | ### `reverse()`
360 | 
361 | `list.reverse(): list`
362 | 
363 | - Reverses the list in place.
364 | - Example: `[1,2,3].reverse()` returns `[3,2,1]`.
365 | 
366 | ### `sort()`
367 | 
368 | `list.sort(): list`
369 | 
370 | - Sorts list elements from smallest to largest.
371 | - Example: `[3, 1, 2].sort()` returns `[1, 2, 3]`.
372 | - Example: `["c", "a", "b"].sort()` returns `["a", "b", "c"]`.
373 | 
374 | ### `flat()`
375 | 
376 | `list.flat(): list`
377 | 
378 | - Flattens nested list into a single list.
379 | - Example: `[1,[2,3]].flat()` returns `[1,2,3]`.
380 | 
381 | ### `unique()`
382 | 
383 | `list.unique(): list`
384 | 
385 | - Removes duplicate elements.
386 | - Example: `[1,2,2,3].unique()` returns `[1,2,3]`.
387 | 
388 | ### `slice()`
389 | 
390 | `list.slice(start: number, end?: number): list`
391 | 
392 | - `start` is the inclusive start index.
393 | - `end` is the optional exclusive end index.
394 | - Returns a shallow copy of a portion of the list from `start` (inclusive) to `end` (exclusive).
395 | - Example: `[1,2,3,4].slice(1,3)` returns `[2,3]`.
396 | - If `end` is omitted, slices to the end of the list.
397 | 
398 | ## Link
399 | 
400 | Functions you can use on a link. Links can be created from a file (`file.asLink()`) or a path (`link("path")`).
401 | 
402 | ### `linksTo()`
403 | 
404 | `link.linksTo(file): boolean`
405 | 
406 | - Returns whether the file represented by the `link` has a link to `file`.
407 | 
408 | ## File
409 | 
410 | Functions you can use with file in the vault, such as `file("notes.md")`.
411 | 
412 | ### `asLink()`
413 | 
414 | `file.asLink(display?: string): Link`
415 | 
416 | - `display` optional display text for the link.
417 | - Returns a Link object that renders as a functioning link.
418 | - Example: `file.asLink()`
419 | 
420 | ### `hasLink()`
421 | 
422 | `file.hasLink(otherFile: file | string): boolean`
423 | 
424 | - `otherFile` is another file object or string path to check.
425 | - Returns true if `file` links to`otherFile`.
426 | - Example: `file.hasLink(otherFile)` returns `true` if there’s a link from `file` to `otherFile`.
427 | 
428 | ### `hasTag()`
429 | 
430 | `file.hasTag(...values: string): boolean`
431 | 
432 | - `values` are one or more tag names.
433 | - Returns true if the file has any of the tags in `values`.
434 | - Example: `file.hasTag("tag1", "tag2")` returns `true` if the file has either tag.
435 | 
436 | ### `inFolder()`
437 | 
438 | `file.inFolder(folder: string): boolean`
439 | 
440 | - `folder` is the folder name to check.
441 | - Returns true if the file is in the specified folder.
442 | - Example: `file.inFolder("notes")` returns `true`.
443 | 
444 | ## Object
445 | 
446 | Functions you can use with a collection of key-value pairs such as `{"a": 1, "b": 2}`.
447 | 
448 | ### `isEmpty()`
449 | 
450 | `object.isEmpty(): boolean`
451 | 
452 | - Returns true if the object has no own properties.
453 | - Example: `{}.isEmpty()` returns `true`.
454 | 
455 | ## Regular expression
456 | 
457 | Functions you can use with a regular expression pattern. Example: `/abc/`.
458 | 
459 | ### `matches()`
460 | 
461 | `regexp.matches(value: string): boolean`
462 | 
463 | - `value` is the string to test.
464 | - Returns true if the regular expression matches `value`.
465 | - Example: `/abc/.matches("abcde")` returns `true`.


--------------------------------------------------------------------------------
/src/lib/BasesUpdater.svelte:
--------------------------------------------------------------------------------
  1 | <script lang="ts">
  2 |   import { BasesUpdater } from './basesUpdater';
  3 |   import { onMount } from 'svelte';
  4 | 
  5 |   let oldBasesYaml = '';
  6 |   let newBasesYaml = '';
  7 |   let updateSummary: string[] = [];
  8 |   let error = '';
  9 |   let isLoading = false;
 10 |   let copySuccess = false;
 11 | 
 12 |   const updater = new BasesUpdater();
 13 | 
 14 |   // Example old syntax for demonstration
 15 |   const exampleOldSyntax = `filters:
 16 |   or:
 17 |     - taggedWith(file.file, "tag")
 18 |     - and:
 19 |         - taggedWith(file.file, "book")
 20 |         - linksTo(file.file, "Textbook")
 21 |     - not:
 22 |         - taggedWith(file.file, "book")
 23 |         - inFolder(file.file, "Required Reading")
 24 | formulas:
 25 |   formatted_price: 'if(price, concat(price.toFixed(2), " dollars"))'
 26 |   ppu: "(price / age).toFixed(2)"
 27 |   full_name: 'join("", first_name, " ", last_name)'
 28 |   description: 'concat("Item: ", title, " - Price: $", price)'
 29 |   category_label: 'join(" | ", category, subcategory, type)'
 30 |   tags_display: 'tags.join(", ")'
 31 |   simple_concat: 'concat("Hello ", name, "!")'
 32 |   nested_example: 'if(available, concat("Available: ", title), "Not available")'
 33 |   complex_join: 'join("", "Product: ", if(title, title, "Unknown"), " (", category, ")")'
 34 | 
 35 | display:
 36 |   status: Status
 37 |   formula.formatted_price: "Price"
 38 |   formula.full_name: "Full Name"
 39 |   formula.description: "Description"
 40 |   formula.nested_example: "Availability"
 41 |   "file.extension": Extension
 42 | views:
 43 |   - type: table
 44 |     name: "My table"
 45 |     limit: 10
 46 |     filters:
 47 |       and:
 48 |         - 'status != "done"'
 49 |         - or:
 50 |             - "formula.ppu > 5"
 51 |             - "price > 2.1"
 52 |     group_by: "status"
 53 |     sort:
 54 |       - column: file.name
 55 |         direction: ASC
 56 |       - column: file.extension
 57 |         direction: DESC
 58 |     order:
 59 |       - file.name
 60 |       - file.extension
 61 |       - property.age
 62 |       - formula.ppu
 63 |       - formula.formatted_price`;
 64 | 
 65 |   function loadExample() {
 66 |     oldBasesYaml = exampleOldSyntax;
 67 |   }
 68 | 
 69 |   function handleDrop(event: DragEvent) {
 70 |     event.preventDefault();
 71 | 
 72 |     if (!event.dataTransfer?.files.length) return;
 73 | 
 74 |     const file = event.dataTransfer.files[0];
 75 |     const reader = new FileReader();
 76 | 
 77 |     reader.onload = (e) => {
 78 |       oldBasesYaml = e.target?.result as string;
 79 |     };
 80 | 
 81 |     reader.readAsText(file);
 82 |   }
 83 | 
 84 |   function preventDefault(event: DragEvent) {
 85 |     event.preventDefault();
 86 |   }
 87 | 
 88 |   function updateBases() {
 89 |     if (!oldBasesYaml.trim()) {
 90 |       newBasesYaml = '';
 91 |       updateSummary = [];
 92 |       error = '';
 93 |       return;
 94 |     }
 95 | 
 96 |     isLoading = true;
 97 |     error = '';
 98 | 
 99 |     try {
100 |       newBasesYaml = updater.updateBasesYaml(oldBasesYaml);
101 |       updateSummary = updater.getUpdateSummary(oldBasesYaml, newBasesYaml);
102 |     } catch (err) {
103 |       error = err instanceof Error ? err.message : 'Unknown error occurred';
104 |       newBasesYaml = '';
105 |       updateSummary = [];
106 |     } finally {
107 |       isLoading = false;
108 |     }
109 |   }
110 | 
111 |   function copyToClipboard() {
112 |     navigator.clipboard.writeText(newBasesYaml).then(() => {
113 |       copySuccess = true;
114 |       setTimeout(() => copySuccess = false, 2000);
115 |     });
116 |   }
117 | 
118 |   function downloadBase() {
119 |     if (!newBasesYaml) return;
120 | 
121 |     const now = new Date();
122 |     const timestamp = now.toISOString().replace(/[-:]/g, '').replace('T', '_').split('.')[0];
123 |     const filename = `Updated base ${timestamp}.base`;
124 | 
125 |     const blob = new Blob([newBasesYaml], { type: 'text/yaml' });
126 |     const url = URL.createObjectURL(blob);
127 | 
128 |     const a = document.createElement('a');
129 |     a.href = url;
130 |     a.download = filename;
131 |     a.click();
132 | 
133 |     URL.revokeObjectURL(url);
134 |   }
135 | 
136 |   // Auto-update when input changes
137 |   $: if (oldBasesYaml !== undefined) {
138 |     updateBases();
139 |   }
140 | 
141 |   // Use example as initial content
142 |   onMount(() => {
143 |     oldBasesYaml = exampleOldSyntax;
144 |   });
145 | </script>
146 | 
147 | <div class="updater-app">
148 |   <div class="updater-header">
149 |     <h2>Bases Syntax Updater</h2>
150 |     <p>Drag and drop a .base file or edit the YAML directly to update to the latest syntax</p>
151 |   </div>
152 | 
153 |   <div class="content-container">
154 |     <div class="editor-container">
155 |       <div
156 |         class="dropzone"
157 |         on:dragover={preventDefault}
158 |         on:dragenter={preventDefault}
159 |         on:drop={handleDrop}
160 |       >
161 |         <p>Drop your .base file here</p>
162 |       </div>
163 | 
164 |       <textarea
165 |         bind:value={oldBasesYaml}
166 |         placeholder="Enter your old Bases YAML here..."
167 |         spellcheck="false"
168 |       ></textarea>
169 | 
170 |       {#if error}
171 |         <div class="error">
172 |           <h3>Error:</h3>
173 |           <pre>{error}</pre>
174 |         </div>
175 |       {/if}
176 | 
177 |       <div class="actions">
178 |         <div class="template-selector">
179 |           <button on:click={loadExample}>
180 |             Load Example
181 |           </button>
182 |         </div>
183 | 
184 | 
185 |       </div>
186 |     </div>
187 | 
188 |     <div class="preview-container">
189 |       {#if isLoading}
190 |         <div class="loading-state">
191 |           <div class="spinner"></div>
192 |           <p>Updating syntax...</p>
193 |         </div>
194 |       {:else if error}
195 |         <div class="error-state">
196 |           <h3>❌ Error</h3>
197 |           <pre>{error}</pre>
198 |         </div>
199 |       {:else if newBasesYaml}
200 |         <div class="result-content">
201 |           <div class="result-header">
202 |             <div class="result-title">
203 |               <h3>Updated Syntax</h3>
204 |               {#if updateSummary.length > 0}
205 |                 <span class="changes-count">{updateSummary.length} changes made</span>
206 |               {/if}
207 |             </div>
208 |             <div class="header-actions">
209 |               <button class="small-button {copySuccess ? 'success' : ''}" on:click={copyToClipboard} disabled={!newBasesYaml || !!error}>
210 |                 {copySuccess ? '✓ Copied!' : '📋 Copy'}
211 |               </button>
212 |               <button class="small-button" on:click={downloadBase} disabled={!newBasesYaml || !!error}>Download as .base</button>
213 |             </div>
214 |           </div>
215 | 
216 |           <textarea
217 |             value={newBasesYaml}
218 |             readonly
219 |             class="yaml-output"
220 |           ></textarea>
221 | 
222 |           {#if updateSummary.length > 0}
223 |             <div class="changes-summary">
224 |               <h4>📋 Changes Made</h4>
225 |               <ul class="changes-list">
226 |                 {#each updateSummary as change}
227 |                   <li>✅ {change}</li>
228 |                 {/each}
229 |               </ul>
230 |             </div>
231 |           {/if}
232 |         </div>
233 |       {:else}
234 |         <div class="empty-state">
235 |           <p>Enter old Bases YAML to see the updated syntax</p>
236 |         </div>
237 |       {/if}
238 |     </div>
239 |   </div>
240 | </div>
241 | 
242 | {#if updateSummary.length > 0 || newBasesYaml}
243 |   <div class="help">
244 |     <h3>🔧 What gets updated?</h3>
245 |     <div class="help-grid">
246 |       <div class="help-item">
247 |         <h4>File Functions</h4>
248 |         <ul>
249 |           <li><code>inFolder(file.file, "folder")</code> → <code>file.inFolder("folder")</code></li>
250 |           <li><code>taggedWith(file.file, "tag")</code> → <code>file.hasTag("tag")</code></li>
251 |           <li><code>linksTo(file.file, "file")</code> → <code>file.hasLink("file")</code></li>
252 |         </ul>
253 |       </div>
254 | 
255 |       <div class="help-item">
256 |         <h4>Boolean Operators</h4>
257 |         <ul>
258 |           <li><code>and</code> → <code>&&</code></li>
259 |           <li><code>or</code> → <code>||</code></li>
260 |           <li><code>not()</code> → <code>!()</code></li>
261 |         </ul>
262 |       </div>
263 | 
264 |       <div class="help-item">
265 |         <h4>String Operations</h4>
266 |         <ul>
267 |           <li><code>concat(a, b, c)</code> → <code>a + b + c</code></li>
268 |           <li><code>join("", a, b)</code> → <code>a + b</code></li>
269 |           <li><code>join(" ", a, b)</code> → <code>a + " " + b</code></li>
270 |           <li><code>array.join("")</code> → <code>array</code></li>
271 |           <li><code>array.join(", ")</code> → <code>array.join(", ")</code></li>
272 |           <li><code>len()</code> → <code>length()</code></li>
273 |           <li><code>empty()</code> → <code>isEmpty()</code></li>
274 |           <li><code>notEmpty()</code> → <code>!isEmpty()</code></li>
275 |         </ul>
276 |       </div>
277 | 
278 |       <div class="help-item">
279 |         <h4>Properties & Functions</h4>
280 |         <ul>
281 |           <li><code>file.extension</code> → <code>file.ext</code></li>
282 |           <li><code>dateFormat()</code> → <code>format()</code></li>
283 |           <li><code>average()</code> → <code>average()</code></li>
284 |         </ul>
285 |       </div>
286 | 
287 |       <div class="help-item">
288 |         <h4>Date & Time</h4>
289 |         <ul>
290 |           <li><code>dateModify(date, "1 day")</code> → <code>date + "1 day"</code></li>
291 |           <li><code>duration("1 day")</code> → <code>"1 day"</code></li>
292 |           <li><code>dateDiff(a, b)</code> → <code>a - b</code></li>
293 |         </ul>
294 |       </div>
295 | 
296 |       <div class="help-item">
297 |         <h4>View Configuration</h4>
298 |         <ul>
299 |           <li>Sort directions: <code>ASC/DESC</code> → <code>asc/desc</code></li>
300 |           <li>Filter syntax updated to new format</li>
301 |           <li>Formula expressions simplified</li>
302 |         </ul>
303 |       </div>
304 |     </div>
305 |   </div>
306 | {/if}
307 | 
308 | <style>
309 |   .updater-app {
310 |     display: flex;
311 |     flex-direction: column;
312 |     height: auto;
313 |     min-height: 100%;
314 |     max-height: 100vh;
315 |     overflow: hidden;
316 |   }
317 | 
318 |   .updater-header {
319 |     text-align: center;
320 |     margin-bottom: 20px;
321 |   }
322 | 
323 |   .updater-header h2 {
324 |     margin-bottom: 5px;
325 |     margin-top: 0;
326 |     color: #50567a;
327 |   }
328 | 
329 |   .updater-header p {
330 |     color: #888;
331 |     margin: 0;
332 |   }
333 | 
334 |   .content-container {
335 |     display: flex;
336 |     gap: 20px;
337 |     flex: 1;
338 |     min-height: 500px;
339 |     max-height: calc(100vh - 200px);
340 |     overflow: hidden;
341 |   }
342 | 
343 |   @media (max-width: 768px) {
344 |     .content-container {
345 |       flex-direction: column;
346 |     }
347 | 
348 |     .result-header {
349 |       padding: 10px 12px;
350 |     }
351 | 
352 |     .result-title {
353 |       flex-direction: column;
354 |       align-items: flex-start;
355 |       gap: 8px;
356 |     }
357 | 
358 |     .header-actions {
359 |       gap: 6px;
360 |       flex-wrap: wrap;
361 |     }
362 | 
363 |     .small-button {
364 |       padding: 5px 10px;
365 |       font-size: 13px;
366 |     }
367 |   }
368 | 
369 |   .editor-container, .preview-container {
370 |     flex: 1;
371 |     background: white;
372 |     border-radius: 8px;
373 |     box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
374 |     overflow: hidden;
375 |     display: flex;
376 |     flex-direction: column;
377 |     min-height: 500px;
378 |   }
379 | 
380 |   .dropzone {
381 |     padding: 20px;
382 |     border: 2px dashed #ddd;
383 |     border-radius: 6px;
384 |     margin: 10px;
385 |     text-align: center;
386 |     color: #888;
387 |     cursor: pointer;
388 |   }
389 | 
390 |   textarea {
391 |     flex-grow: 1;
392 |     padding: 10px;
393 |     font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', 'Consolas', 'source-code-pro', monospace;
394 |     font-size: 14px;
395 |     border: none;
396 |     border-top: 1px solid #eee;
397 |     resize: none;
398 |     outline: none;
399 |     line-height: 1.4;
400 |     min-height: 0;
401 |   }
402 | 
403 |   .error {
404 |     padding: 10px;
405 |     margin: 10px;
406 |     background: #fff0f0;
407 |     border-left: 3px solid #f00;
408 |   }
409 | 
410 |   .error h3 {
411 |     color: #d00;
412 |     margin: 0 0 5px 0;
413 |     font-size: 16px;
414 |   }
415 | 
416 |   .error pre {
417 |     margin: 0;
418 |     font-family: monospace;
419 |     overflow-x: auto;
420 |   }
421 | 
422 |   .actions {
423 |     padding: 10px;
424 |     border-top: 1px solid #eee;
425 |     display: flex;
426 |     justify-content: space-between;
427 |   }
428 | 
429 |   .actions button {
430 |     background: #50567a;
431 |     color: white;
432 |     border: none;
433 |     padding: 8px 12px;
434 |     border-radius: 4px;
435 |     cursor: pointer;
436 |     font-size: 14px;
437 |   }
438 | 
439 |   .actions button:hover {
440 |     background: #3a3f5a;
441 |   }
442 | 
443 |   .actions button:disabled {
444 |     background: #a0a0a0;
445 |     cursor: not-allowed;
446 |   }
447 | 
448 |   .header-actions {
449 |     display: flex;
450 |     gap: 8px;
451 |   }
452 | 
453 |   .small-button {
454 |     background: white;
455 |     color: #555;
456 |     border: 1px solid #ddd;
457 |     padding: 6px 12px;
458 |     border-radius: 4px;
459 |     cursor: pointer;
460 |     font-size: 14px;
461 |     font-weight: 500;
462 |     transition: all 0.2s ease;
463 |   }
464 | 
465 |   .small-button:hover {
466 |     background: #f0f0f0;
467 |     border-color: #ccc;
468 |   }
469 | 
470 |   .small-button.success {
471 |     background: #4caf50;
472 |     color: white;
473 |     border-color: #4caf50;
474 |   }
475 | 
476 |   .small-button:disabled {
477 |     background: #f5f5f5;
478 |     color: #a0a0a0;
479 |     border-color: #e0e0e0;
480 |     cursor: not-allowed;
481 |   }
482 | 
483 |   .template-selector {
484 |     position: relative;
485 |   }
486 | 
487 |   .loading-state, .error-state, .empty-state {
488 |     display: flex;
489 |     align-items: center;
490 |     justify-content: center;
491 |     height: 100%;
492 |     color: #888;
493 |     flex-direction: column;
494 |     gap: 10px;
495 |   }
496 | 
497 |   .spinner {
498 |     width: 20px;
499 |     height: 20px;
500 |     border: 2px solid #e9ecef;
501 |     border-top: 2px solid #50567a;
502 |     border-radius: 50%;
503 |     animation: spin 1s linear infinite;
504 |   }
505 | 
506 |   @keyframes spin {
507 |     0% { transform: rotate(0deg); }
508 |     100% { transform: rotate(360deg); }
509 |   }
510 | 
511 |   .result-content {
512 |     display: flex;
513 |     flex-direction: column;
514 |     height: 100%;
515 |   }
516 | 
517 |   .result-header {
518 |     padding: 12px 16px;
519 |     border-bottom: 1px solid #eee;
520 |     background: #f6f8fa;
521 |     display: flex;
522 |     justify-content: space-between;
523 |     align-items: center;
524 |   }
525 | 
526 |   .result-title {
527 |     display: flex;
528 |     align-items: center;
529 |     gap: 12px;
530 |   }
531 | 
532 |   .result-header h3 {
533 |     margin: 0;
534 |     color: #50567a;
535 |     font-size: 16px;
536 |     font-weight: 600;
537 |   }
538 | 
539 |   .changes-count {
540 |     background: #28a745;
541 |     color: white;
542 |     padding: 2px 8px;
543 |     border-radius: 12px;
544 |     font-size: 12px;
545 |   }
546 |  
547 |   .yaml-output {
548 |     flex: 1;
549 |     padding: 10px;
550 |     font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', 'Consolas', 'source-code-pro', monospace;
551 |     font-size: 14px;
552 |     border: none;
553 |     resize: none;
554 |     outline: none;
555 |     line-height: 1.4;
556 |     background: #f8f9fa;
557 |     min-height: 0;
558 |   }
559 | 
560 |   .changes-summary {
561 |     padding: 10px;
562 |     border-top: 1px solid #eee;
563 |     background: #f9f9f9;
564 |     max-height: 200px;
565 |     overflow-y: auto;
566 |   }
567 | 
568 |   .changes-summary h4 {
569 |     margin: 0 0 10px 0;
570 |     color: #28a745;
571 |     font-size: 14px;
572 |   }
573 | 
574 |   .changes-list {
575 |     margin: 0;
576 |     padding-left: 20px;
577 |     font-size: 13px;
578 |   }
579 | 
580 |   .changes-list li {
581 |     margin-bottom: 5px;
582 |     color: #333;
583 |     line-height: 1.3;
584 |   }
585 | 
586 |   .help {
587 |     background: white;
588 |     padding: 30px;
589 |     border-radius: 8px;
590 |     box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
591 |     margin-top: 20px;
592 |   }
593 | 
594 |   .help h3 {
595 |     margin: 0 0 20px 0;
596 |     color: #50567a;
597 |     font-size: 1.2rem;
598 |     font-weight: 600;
599 |   }
600 | 
601 |   .help-grid {
602 |     display: grid;
603 |     grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
604 |     gap: 20px;
605 |   }
606 | 
607 |   .help-item {
608 |     background: #f8f9fa;
609 |     padding: 15px;
610 |     border-radius: 6px;
611 |     border: 1px solid #e9ecef;
612 |   }
613 | 
614 |   .help-item h4 {
615 |     margin: 0 0 10px 0;
616 |     color: #495057;
617 |     font-size: 14px;
618 |     font-weight: 600;
619 |   }
620 | 
621 |   .help-item ul {
622 |     margin: 0;
623 |     padding-left: 16px;
624 |   }
625 | 
626 |   .help-item li {
627 |     margin-bottom: 4px;
628 |     font-size: 13px;
629 |     line-height: 1.3;
630 |     color: #333;
631 |   }
632 | 
633 |   .help-item code {
634 |     background: #e9ecef;
635 |     padding: 2px 4px;
636 |     border-radius: 3px;
637 |     font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', 'Consolas', 'source-code-pro', monospace;
638 |     font-size: 12px;
639 |     color: #e83e8c;
640 |   }
641 | 
642 |   @media (max-width: 768px) {
643 |     .help-grid {
644 |       grid-template-columns: 1fr;
645 |     }
646 |   }
647 | </style>


--------------------------------------------------------------------------------
/src/lib/basesUpdater.ts:
--------------------------------------------------------------------------------
  1 | import * as yaml from "js-yaml";
  2 | 
  3 | /**
  4 |  * Bases Updater - Converts old Bases syntax to new syntax
  5 |  */
  6 | export class BasesUpdater {
  7 |   /**
  8 |    * Convert old Bases YAML to new syntax
  9 |    */
 10 |   updateBasesYaml(oldYaml: string): string {
 11 |     try {
 12 |       const parsed = yaml.load(oldYaml) as any;
 13 |       const updated = this.updateBasesObject(parsed);
 14 |       let result = yaml.dump(updated, {
 15 |         quotingType: '"',
 16 |         forceQuotes: false,
 17 |         lineWidth: -1,
 18 |       });
 19 | 
 20 |       // Post-process to fix over-escaped string concatenation expressions
 21 |       result = this.fixEscapedStringConcatenation(result);
 22 | 
 23 |       return result;
 24 |     } catch (error: unknown) {
 25 |       const errorMessage =
 26 |         error instanceof Error ? error.message : "Unknown error occurred";
 27 |       throw new Error(`Failed to parse YAML: ${errorMessage}`);
 28 |     }
 29 |   }
 30 | 
 31 |   /**
 32 |    * Update a Bases object to new syntax
 33 |    */
 34 |   private updateBasesObject(bases: any): any {
 35 |     if (!bases || typeof bases !== "object") {
 36 |       return bases;
 37 |     }
 38 | 
 39 |     const updated = { ...bases };
 40 | 
 41 |     // Update filters
 42 |     if (updated.filters) {
 43 |       updated.filters = this.updateFilters(updated.filters);
 44 |     }
 45 | 
 46 |     // Update formulas
 47 |     if (updated.formulas) {
 48 |       updated.formulas = this.updateFormulas(updated.formulas);
 49 |     }
 50 | 
 51 |     // Update views
 52 |     if (updated.views && Array.isArray(updated.views)) {
 53 |       updated.views = updated.views.map((view: any) => this.updateView(view));
 54 |     }
 55 | 
 56 |     // Update display properties
 57 |     if (updated.display) {
 58 |       updated.display = this.updateDisplayProperties(updated.display);
 59 |     }
 60 | 
 61 |     return updated;
 62 |   }
 63 | 
 64 |   /**
 65 |    * Update filters to new syntax
 66 |    */
 67 |   private updateFilters(filters: any): any {
 68 |     if (typeof filters === "string") {
 69 |       return this.updateFilterExpression(filters);
 70 |     }
 71 | 
 72 |     if (typeof filters === "object" && filters !== null) {
 73 |       const updated: any = {};
 74 | 
 75 |       for (const [key, value] of Object.entries(filters)) {
 76 |         if (key === "and" || key === "or" || key === "not") {
 77 |           if (Array.isArray(value)) {
 78 |             updated[key] = value.map((item) => this.updateFilters(item));
 79 |           } else {
 80 |             updated[key] = this.updateFilters(value);
 81 |           }
 82 |         } else {
 83 |           updated[key] = value;
 84 |         }
 85 |       }
 86 | 
 87 |       return updated;
 88 |     }
 89 | 
 90 |     return filters;
 91 |   }
 92 | 
 93 |   /**
 94 |    * Update a single filter expression string
 95 |    */
 96 |   private updateFilterExpression(expression: string): string {
 97 |     let updated = expression;
 98 | 
 99 |     // Update function calls
100 |     const functionUpdates: Record<string, string> = {
101 |       // File functions - convert to method style
102 |       "inFolder\\(file\\.file,\\s*([^)]+)\\)": "file.inFolder($1)",
103 |       "taggedWith\\(file\\.file,\\s*([^)]+)\\)": "file.hasTag($1)",
104 |       "linksTo\\(file\\.file,\\s*([^)]+)\\)": "file.hasLink($1)",
105 | 
106 |       // Boolean operators
107 |       "\\s+and\\s+": " && ",
108 |       "\\s+or\\s+": " || ",
109 |       "not\\(([^)]+)\\)": "!($1)",
110 | 
111 |       // Function name updates
112 |       "\\blen\\(": "length(",
113 |       "\\bcontainsAny\\(": "containsAny(",
114 |       "\\bcontainsAll\\(": "containsAll(",
115 |       "\\bstartswith\\(": "startsWith(",
116 |       "\\bendswith\\(": "endsWith(",
117 |       "\\bempty\\(": "isEmpty(",
118 |       "\\bnotEmpty\\(": "!isEmpty(",
119 |       "\\baverage\\(": "average(",
120 | 
121 |       // Date functions
122 |       "\\bdateFormat\\(": "format(",
123 |       "\\bdateModify\\(": "+",
124 |       "\\bdateDiff\\(": "-",
125 | 
126 |       // Property updates
127 |       "\\bfile\\.extension\\b": "file.ext",
128 | 
129 |       // Duration format updates
130 |       'duration\\("([^"]+)"\\)': '"$1"',
131 |     };
132 | 
133 |     for (const [pattern, replacement] of Object.entries(functionUpdates)) {
134 |       const regex = new RegExp(pattern, "g");
135 |       updated = updated.replace(regex, replacement);
136 |     }
137 | 
138 |     // Handle string concatenation functions
139 |     updated = this.convertStringConcatenation(updated);
140 | 
141 |     // Handle date arithmetic - convert dateModify calls to + operator
142 |     updated = updated.replace(
143 |       /dateModify\(([^,]+),\s*"([^"]+)"\)/g,
144 |       '$1 + "$2"'
145 |     );
146 | 
147 |     // Handle negated duration in date arithmetic
148 |     updated = updated.replace(/\+\s*"-([^"]+)"/g, '+ "-$1"');
149 | 
150 |     return updated;
151 |   }
152 | 
153 |   /**
154 |    * Update formulas to new syntax
155 |    */
156 |   private updateFormulas(
157 |     formulas: Record<string, string>
158 |   ): Record<string, string> {
159 |     const updated: Record<string, string> = {};
160 | 
161 |     for (const [key, formula] of Object.entries(formulas)) {
162 |       updated[key] = this.updateFormulaExpression(formula);
163 |     }
164 | 
165 |     return updated;
166 |   }
167 | 
168 |   /**
169 |    * Update a single formula expression
170 |    */
171 |   private updateFormulaExpression(formula: string): string {
172 |     let updated = formula;
173 | 
174 |     // Update function calls in formulas
175 |     const formulaUpdates: Record<string, string> = {
176 |       // Method calls
177 |       "\\.toFixed\\(": ".toFixed(",
178 |       "\\.toString\\(": ".toString(",
179 |       "\\.trim\\(": ".trim(",
180 |       "\\.title\\(": ".title(",
181 |       "\\.split\\(": ".split(",
182 |       "\\.replace\\(": ".replace(",
183 |       "\\.slice\\(": ".slice(",
184 |       "\\.reverse\\(": ".reverse(",
185 |       "\\.sort\\(": ".sort(",
186 |       "\\.flat\\(": ".flat(",
187 |       "\\.unique\\(": ".unique(",
188 |       "\\.contains\\(": ".contains(",
189 |       "\\.containsAny\\(": ".containsAny(",
190 |       "\\.containsAll\\(": ".containsAll(",
191 |       "\\.startsWith\\(": ".startsWith(",
192 |       "\\.endsWith\\(": ".endsWith(",
193 |       "\\.isEmpty\\(": ".isEmpty(",
194 | 
195 |       // Math functions
196 |       "\\.round\\(": ".round(",
197 |       "\\.floor\\(": ".floor(",
198 |       "\\.ceil\\(": ".ceil(",
199 |       "\\.abs\\(": ".abs(",
200 | 
201 |       // Date properties
202 |       "\\.year\\b": ".year",
203 |       "\\.month\\b": ".month",
204 |       "\\.day\\b": ".day",
205 |       "\\.hour\\b": ".hour",
206 |       "\\.minute\\b": ".minute",
207 |       "\\.second\\b": ".second",
208 |       "\\.millisecond\\b": ".millisecond",
209 | 
210 |       // Date methods
211 |       "\\.format\\(": ".format(",
212 |       "\\.date\\(": ".date(",
213 |       "\\.time\\(": ".time(",
214 | 
215 |       // Array/String methods
216 |       "\\.length\\b": ".length",
217 | 
218 |       // Boolean operators in formulas
219 |       "\\s+and\\s+": " && ",
220 |       "\\s+or\\s+": " || ",
221 | 
222 |       // Function name updates
223 |       "\\blen\\(": "length(",
224 |       "\\baverage\\(": "average(",
225 |     };
226 | 
227 |     for (const [pattern, replacement] of Object.entries(formulaUpdates)) {
228 |       const regex = new RegExp(pattern, "g");
229 |       updated = updated.replace(regex, replacement);
230 |     }
231 | 
232 |     // Handle string concatenation functions
233 |     updated = this.convertStringConcatenation(updated);
234 | 
235 |     return updated;
236 |   }
237 | 
238 |   /**
239 |    * Update view configuration
240 |    */
241 |   private updateView(view: any): any {
242 |     if (!view || typeof view !== "object") {
243 |       return view;
244 |     }
245 | 
246 |     const updated = { ...view };
247 | 
248 |     // Update filters in view
249 |     if (updated.filters) {
250 |       updated.filters = this.updateFilters(updated.filters);
251 |     }
252 | 
253 |     // Update sort configuration
254 |     if (updated.sort && Array.isArray(updated.sort)) {
255 |       updated.sort = updated.sort.map((sortItem: any) => {
256 |         if (typeof sortItem === "object" && sortItem.direction) {
257 |           return {
258 |             ...sortItem,
259 |             direction: sortItem.direction.toLowerCase(), // ASC/DESC -> asc/desc
260 |           };
261 |         }
262 |         return sortItem;
263 |       });
264 |     }
265 | 
266 |     return updated;
267 |   }
268 | 
269 |   /**
270 |    * Update display property names
271 |    */
272 |   private updateDisplayProperties(
273 |     display: Record<string, string>
274 |   ): Record<string, string> {
275 |     const updated: Record<string, string> = {};
276 | 
277 |     for (const [key, value] of Object.entries(display)) {
278 |       let updatedKey = key;
279 | 
280 |       // Update property names
281 |       if (key === "file.extension") {
282 |         updatedKey = "file.ext";
283 |       }
284 | 
285 |       updated[updatedKey] = value;
286 |     }
287 | 
288 |     return updated;
289 |   }
290 | 
291 |   /**
292 |    * Get a summary of changes made
293 |    */
294 |   getUpdateSummary(oldYaml: string, newYaml: string): string[] {
295 |     const changes: string[] = [];
296 | 
297 |     // Check for specific patterns that were updated
298 |     const patterns = [
299 |       {
300 |         old: /inFolder\(file\.file,/,
301 |         new: /file\.inFolder\(/,
302 |         desc: "Updated inFolder() to file.inFolder()",
303 |       },
304 |       {
305 |         old: /taggedWith\(file\.file,/,
306 |         new: /file\.hasTag\(/,
307 |         desc: "Updated taggedWith() to file.hasTag()",
308 |       },
309 |       {
310 |         old: /linksTo\(file\.file,/,
311 |         new: /file\.hasLink\(/,
312 |         desc: "Updated linksTo() to file.hasLink()",
313 |       },
314 |       { old: /\sand\s/, new: /&&/, desc: 'Updated "and" to "&&"' },
315 |       { old: /\sor\s/, new: /\|\|/, desc: 'Updated "or" to "||"' },
316 |       { old: /not\(/, new: /!\(/, desc: "Updated not() to !()" },
317 |       {
318 |         old: /file\.extension/,
319 |         new: /file\.ext/,
320 |         desc: "Updated file.extension to file.ext",
321 |       },
322 |       {
323 |         old: /dateModify\(/,
324 |         new: /\+/,
325 |         desc: "Updated dateModify() to + operator",
326 |       },
327 |       {
328 |         old: /ASC|DESC/,
329 |         new: /asc|desc/,
330 |         desc: "Updated sort direction to lowercase",
331 |       },
332 |       {
333 |         old: /concat\(/,
334 |         new: /\+/,
335 |         desc: "Updated concat() to + operator for string concatenation",
336 |       },
337 |       {
338 |         old: /join\("",/,
339 |         new: /\+/,
340 |         desc: 'Updated join("", ...) to + operator for string concatenation',
341 |       },
342 |       {
343 |         old: /join\("[^"]*",/,
344 |         new: /\+/,
345 |         desc: "Updated join() with separator to + operator",
346 |       },
347 |       {
348 |         old: /\.join\(""/,
349 |         new: /\+/,
350 |         desc: 'Updated .join("") to + operator for string concatenation',
351 |       },
352 |       {
353 |         old: /duration\("/,
354 |         new: /"/,
355 |         desc: "Updated duration() function to string format",
356 |       },
357 |       { old: /len\(/, new: /length\(/, desc: "Updated len() to length()" },
358 |       {
359 |         old: /empty\(/,
360 |         new: /isEmpty\(/,
361 |         desc: "Updated empty() to isEmpty()",
362 |       },
363 |       {
364 |         old: /notEmpty\(/,
365 |         new: /!isEmpty\(/,
366 |         desc: "Updated notEmpty() to !isEmpty()",
367 |       },
368 |     ];
369 | 
370 |     for (const pattern of patterns) {
371 |       if (pattern.old.test(oldYaml) && pattern.new.test(newYaml)) {
372 |         changes.push(pattern.desc);
373 |       }
374 |     }
375 | 
376 |     return changes;
377 |   }
378 | 
379 |   /**
380 |    * Convert string concatenation functions to + operator
381 |    */
382 |   private convertStringConcatenation(expression: string): string {
383 |     let updated = expression;
384 |     let previousUpdate = "";
385 | 
386 |     // Keep applying transformations until no more changes are made
387 |     while (updated !== previousUpdate) {
388 |       previousUpdate = updated;
389 | 
390 |       // Handle concat() function calls
391 |       updated = this.replaceFunctionCalls(updated, "concat", (args) => {
392 |         const argList = this.parseArguments(args);
393 |         return argList.join(" + ");
394 |       });
395 | 
396 |       // Handle join() function calls with empty string separator
397 |       updated = this.replaceFunctionCalls(updated, "join", (args) => {
398 |         const argList = this.parseArguments(args);
399 |         if (
400 |           argList.length > 0 &&
401 |           (argList[0] === '""' || argList[0] === "''")
402 |         ) {
403 |           // Remove the empty separator and join the rest
404 |           return argList.slice(1).join(" + ");
405 |         }
406 |         // Handle join with separator
407 |         if (argList.length > 1) {
408 |           const separator = argList[0];
409 |           const cleanSeparator = separator.slice(1, -1); // Remove quotes
410 |           if (cleanSeparator === "") {
411 |             return argList.slice(1).join(" + ");
412 |           } else {
413 |             return argList.slice(1).join(` + ${separator} + `);
414 |           }
415 |         }
416 |         return args; // Return original if can't parse
417 |       });
418 |     }
419 | 
420 |     // Handle .join() method calls on arrays
421 |     updated = updated.replace(
422 |       /(\w+)\.join\s*\(\s*"([^"]*)"\s*\)/g,
423 |       (match, arrayName, separator) => {
424 |         if (separator === "") {
425 |           return arrayName; // Direct concatenation for empty separator
426 |         } else {
427 |           return `${arrayName}.join("${separator}")`;
428 |         }
429 |       }
430 |     );
431 | 
432 |     return updated;
433 |   }
434 | 
435 |   /**
436 |    * Replace function calls with a transformation function
437 |    */
438 |   private replaceFunctionCalls(
439 |     text: string,
440 |     functionName: string,
441 |     transform: (args: string) => string
442 |   ): string {
443 |     const regex = new RegExp(`\\b${functionName}\\s*\\(`, "g");
444 |     let result = "";
445 |     let lastIndex = 0;
446 |     let match;
447 | 
448 |     while ((match = regex.exec(text)) !== null) {
449 |       const startIndex = match.index;
450 |       const openParenIndex = match.index + match[0].length - 1;
451 | 
452 |       // Add text before the function call
453 |       result += text.substring(lastIndex, startIndex);
454 | 
455 |       // Find the matching closing parenthesis
456 |       const args = this.extractArgumentsFromPosition(text, openParenIndex);
457 |       if (args !== null) {
458 |         // Apply the transformation
459 |         const transformed = transform(args);
460 |         result += transformed;
461 |         lastIndex = openParenIndex + args.length + 2; // +2 for the parentheses
462 |       } else {
463 |         // If we can't parse it, keep the original
464 |         result += match[0];
465 |         lastIndex = regex.lastIndex;
466 |       }
467 |     }
468 | 
469 |     // Add remaining text
470 |     result += text.substring(lastIndex);
471 |     return result;
472 |   }
473 | 
474 |   /**
475 |    * Extract arguments from a function call starting at the opening parenthesis
476 |    */
477 |   private extractArgumentsFromPosition(
478 |     text: string,
479 |     openParenIndex: number
480 |   ): string | null {
481 |     let depth = 0;
482 |     let inQuotes = false;
483 |     let quoteChar = "";
484 |     let i = openParenIndex;
485 | 
486 |     while (i < text.length) {
487 |       const char = text[i];
488 |       const prevChar = i > 0 ? text[i - 1] : "";
489 | 
490 |       if ((char === '"' || char === "'") && prevChar !== "\\") {
491 |         if (!inQuotes) {
492 |           inQuotes = true;
493 |           quoteChar = char;
494 |         } else if (char === quoteChar) {
495 |           inQuotes = false;
496 |           quoteChar = "";
497 |         }
498 |       }
499 | 
500 |       if (!inQuotes) {
501 |         if (char === "(") {
502 |           depth++;
503 |         } else if (char === ")") {
504 |           depth--;
505 |           if (depth === 0) {
506 |             // Found the matching closing parenthesis
507 |             return text.substring(openParenIndex + 1, i);
508 |           }
509 |         }
510 |       }
511 | 
512 |       i++;
513 |     }
514 | 
515 |     return null;
516 |   }
517 | 
518 |   /**
519 |    * Extract a complete function call with proper parentheses matching
520 |    */
521 |   private extractFunctionCall(
522 |     text: string,
523 |     startOffset: number,
524 |     functionName: string
525 |   ): { args: string } | null {
526 |     // Find the opening parenthesis
527 |     const openParenIndex = text.indexOf("(", startOffset);
528 |     if (openParenIndex === -1) return null;
529 | 
530 |     const args = this.extractArgumentsFromPosition(text, openParenIndex);
531 |     return args !== null ? { args } : null;
532 |   }
533 | 
534 |   /**
535 |    * Parse function arguments, handling nested parentheses and quotes
536 |    */
537 |   private parseArguments(argsString: string): string[] {
538 |     const args: string[] = [];
539 |     let current = "";
540 |     let depth = 0;
541 |     let inQuotes = false;
542 |     let quoteChar = "";
543 | 
544 |     for (let i = 0; i < argsString.length; i++) {
545 |       const char = argsString[i];
546 |       const prevChar = i > 0 ? argsString[i - 1] : "";
547 | 
548 |       if ((char === '"' || char === "'") && prevChar !== "\\") {
549 |         if (!inQuotes) {
550 |           inQuotes = true;
551 |           quoteChar = char;
552 |         } else if (char === quoteChar) {
553 |           inQuotes = false;
554 |           quoteChar = "";
555 |         }
556 |       }
557 | 
558 |       if (!inQuotes) {
559 |         if (char === "(") {
560 |           depth++;
561 |         } else if (char === ")") {
562 |           depth--;
563 |         } else if (char === "," && depth === 0) {
564 |           args.push(current.trim());
565 |           current = "";
566 |           continue;
567 |         }
568 |       }
569 | 
570 |       current += char;
571 |     }
572 | 
573 |     if (current.trim()) {
574 |       args.push(current.trim());
575 |     }
576 | 
577 |     return args;
578 |   }
579 | 
580 |   /**
581 |    * Fix over-escaped string concatenation expressions in YAML output
582 |    */
583 |   private fixEscapedStringConcatenation(yamlString: string): string {
584 |     // Fix expressions that contain string concatenation with + operator
585 |     // Pattern: key: "\"string\" + variable + \"string\""
586 |     // Should become: key: "string" + variable + "string"
587 |     return yamlString.replace(
588 |       /^(\s*)([^:\s]+):\s*"((?:[^"\\]|\\.)*)"\s*$/gm,
589 |       (match, indent, key, expression) => {
590 |         // Check if this looks like a string concatenation expression with escaped quotes
591 |         if (expression.includes(' + ') && expression.includes('\\"')) {
592 |           // Unescape the quotes in the expression and remove the outer quotes
593 |           const unescaped = expression.replace(/\\"/g, '"');
594 |           return `${indent}${key}: ${unescaped}`;
595 |         }
596 |         return match; // Return original if it doesn't match our pattern
597 |       }
598 |     );
599 |   }
600 | }
601 | 


--------------------------------------------------------------------------------
/src/dataview-parser/expression-parse.ts:
--------------------------------------------------------------------------------
  1 | import type { Literal } from "./field";
  2 | import * as P from "parsimmon";
  3 | import type {
  4 |   BinaryOp,
  5 |   Field,
  6 |   LambdaField,
  7 |   ListField,
  8 |   LiteralField,
  9 |   ObjectField,
 10 |   VariableField,
 11 | } from "./field";
 12 | import { Fields } from "./field";
 13 | import type {
 14 |   FolderSource,
 15 |   NegatedSource,
 16 |   Source,
 17 |   SourceOp,
 18 |   TagSource,
 19 |   CsvSource,
 20 | } from "./source-types";
 21 | import { DateTime, Duration } from "luxon";
 22 | import { Sources } from "./source-types";
 23 | import { Result } from "./query-types";
 24 | import emojiRegex from "emoji-regex";
 25 | import { Link } from "./normalize";
 26 | 
 27 | /** Emoji regex without any additional flags. */
 28 | const EMOJI_REGEX = new RegExp(emojiRegex(), "");
 29 | 
 30 | /** Normalize a duration to all of the proper units. */
 31 | export function normalizeDuration(dur: Duration) {
 32 |   if (dur === undefined || dur === null) return dur;
 33 | 
 34 |   return dur.shiftToAll().normalize();
 35 | }
 36 | 
 37 | /** Provides a lookup table for unit durations of the given type. */
 38 | export const DURATION_TYPES = {
 39 |   year: Duration.fromObject({ years: 1 }),
 40 |   years: Duration.fromObject({ years: 1 }),
 41 |   yr: Duration.fromObject({ years: 1 }),
 42 |   yrs: Duration.fromObject({ years: 1 }),
 43 | 
 44 |   month: Duration.fromObject({ months: 1 }),
 45 |   months: Duration.fromObject({ months: 1 }),
 46 |   mo: Duration.fromObject({ months: 1 }),
 47 |   mos: Duration.fromObject({ months: 1 }),
 48 | 
 49 |   week: Duration.fromObject({ weeks: 1 }),
 50 |   weeks: Duration.fromObject({ weeks: 1 }),
 51 |   wk: Duration.fromObject({ weeks: 1 }),
 52 |   wks: Duration.fromObject({ weeks: 1 }),
 53 |   w: Duration.fromObject({ weeks: 1 }),
 54 | 
 55 |   day: Duration.fromObject({ days: 1 }),
 56 |   days: Duration.fromObject({ days: 1 }),
 57 |   d: Duration.fromObject({ days: 1 }),
 58 | 
 59 |   hour: Duration.fromObject({ hours: 1 }),
 60 |   hours: Duration.fromObject({ hours: 1 }),
 61 |   hr: Duration.fromObject({ hours: 1 }),
 62 |   hrs: Duration.fromObject({ hours: 1 }),
 63 |   h: Duration.fromObject({ hours: 1 }),
 64 | 
 65 |   minute: Duration.fromObject({ minutes: 1 }),
 66 |   minutes: Duration.fromObject({ minutes: 1 }),
 67 |   min: Duration.fromObject({ minutes: 1 }),
 68 |   mins: Duration.fromObject({ minutes: 1 }),
 69 |   m: Duration.fromObject({ minutes: 1 }),
 70 | 
 71 |   second: Duration.fromObject({ seconds: 1 }),
 72 |   seconds: Duration.fromObject({ seconds: 1 }),
 73 |   sec: Duration.fromObject({ seconds: 1 }),
 74 |   secs: Duration.fromObject({ seconds: 1 }),
 75 |   s: Duration.fromObject({ seconds: 1 }),
 76 | };
 77 | 
 78 | /** Shorthand for common dates (relative to right now). */
 79 | export const DATE_SHORTHANDS = {
 80 |   now: () => "now()",
 81 |   today: () => "now()",
 82 |   yesterday: () => "dateModify(date(now()), -1 day)",
 83 |   tomorrow: () => "dateModify(date(now()), 1 day)",
 84 |   sow: () => "dateModify(date(now()), -day(now()) + 1 day)",
 85 |   "start-of-week": () => "dateModify(date(now()), -day(now()) + 1 day)",
 86 |   eow: () => "dateModify(date(now()), 7 - day(now()) day)",
 87 |   "end-of-week": () => "dateModify(date(now()), 7 - day(now()) day)",
 88 |   soy: () => "date(year(now()) + '-01-01')",
 89 |   "start-of-year": () => "date(year(now()) + '-01-01')",
 90 |   eoy: () => "date(year(now()) + '-12-31')",
 91 |   "end-of-year": () => "date(year(now()) + '-12-31')",
 92 |   som: () => "date(year(now()) + '-' + month(now()) + '-01')",
 93 |   "start-of-month": () => "date(year(now()) + '-' + month(now()) + '-01')",
 94 |   eom: () =>
 95 |     "dateModify(date(year(now()) + '-' + month(now()) + '-01'), 1 month, -1 day)",
 96 |   "end-of-month": () =>
 97 |     "dateModify(date(year(now()) + '-' + month(now()) + '-01'), 1 month, -1 day)",
 98 | };
 99 | 
100 | /**
101 |  * Keywords which cannot be used as variables directly. Use `row.<thing>` if it is a variable you have defined and want
102 |  * to access.
103 |  */
104 | export const KEYWORDS = ["FROM", "WHERE", "LIMIT", "GROUP", "FLATTEN"];
105 | 
106 | ///////////////
107 | // Utilities //
108 | ///////////////
109 | 
110 | /** Split on unescaped pipes in an inner link. */
111 | function splitOnUnescapedPipe(link: string): [string, string | undefined] {
112 |   let pipe = -1;
113 |   while ((pipe = link.indexOf("|", pipe + 1)) >= 0) {
114 |     if (pipe > 0 && link[pipe - 1] == "\\") continue;
115 |     return [
116 |       link.substring(0, pipe).replace(/\\\|/g, "|"),
117 |       link.substring(pipe + 1),
118 |     ];
119 |   }
120 | 
121 |   return [link.replace(/\\\|/g, "|"), undefined];
122 | }
123 | 
124 | /** Attempt to parse the inside of a link to pull out display name, subpath, etc. */
125 | export function parseInnerLink(rawlink: string): Link {
126 |   let [link, display] = splitOnUnescapedPipe(rawlink);
127 |   return Link.infer(link, false, display);
128 | }
129 | 
130 | /** Create a left-associative binary parser which parses the given sub-element and separator. Handles whitespace. */
131 | export function createBinaryParser<T, U>(
132 |   child: P.Parser<T>,
133 |   sep: P.Parser<U>,
134 |   combine: (a: T, b: U, c: T) => T
135 | ): P.Parser<T> {
136 |   return P.seqMap(
137 |     child,
138 |     P.seq(P.optWhitespace, sep, P.optWhitespace, child).many(),
139 |     (first, rest) => {
140 |       if (rest.length == 0) return first;
141 | 
142 |       let node = combine(first, rest[0][1], rest[0][3]);
143 |       for (let index = 1; index < rest.length; index++) {
144 |         node = combine(node, rest[index][1], rest[index][3]);
145 |       }
146 |       return node;
147 |     }
148 |   );
149 | }
150 | 
151 | export function chainOpt<T>(
152 |   base: P.Parser<T>,
153 |   ...funcs: ((r: T) => P.Parser<T>)[]
154 | ): P.Parser<T> {
155 |   return P.custom((success, failure) => {
156 |     return (input, i) => {
157 |       let result = (base as any)._(input, i);
158 |       if (!result.status) return result;
159 | 
160 |       for (let func of funcs) {
161 |         let next = (func(result.value as T) as any)._(input, result.index);
162 |         if (!next.status) return result;
163 | 
164 |         result = next;
165 |       }
166 | 
167 |       return result;
168 |     };
169 |   });
170 | }
171 | 
172 | ////////////////////////
173 | // Expression Parsing //
174 | ////////////////////////
175 | 
176 | export type PostfixFragment =
177 |   | { type: "dot"; field: string }
178 |   | { type: "index"; field: Field }
179 |   | { type: "function"; fields: Field[] };
180 | 
181 | export interface ExpressionLanguage {
182 |   number: number;
183 |   string: string;
184 |   escapeCharacter: string;
185 |   bool: boolean;
186 |   tag: string;
187 |   identifier: string;
188 |   link: Link;
189 |   embedLink: Link;
190 |   rootDate: DateTime;
191 |   dateShorthand: keyof typeof DATE_SHORTHANDS;
192 |   date: DateTime;
193 |   datePlus: DateTime;
194 |   durationType: keyof typeof DURATION_TYPES;
195 |   duration: Duration;
196 |   rawNull: string;
197 | 
198 |   binaryPlusMinus: BinaryOp;
199 |   binaryMulDiv: BinaryOp;
200 |   binaryCompareOp: BinaryOp;
201 |   binaryBooleanOp: BinaryOp;
202 | 
203 |   // Source-related parsers.
204 |   tagSource: TagSource;
205 |   csvSource: CsvSource;
206 |   folderSource: FolderSource;
207 |   parensSource: Source;
208 |   atomSource: Source;
209 |   linkIncomingSource: Source;
210 |   linkOutgoingSource: Source;
211 |   negateSource: NegatedSource;
212 |   binaryOpSource: Source;
213 |   source: Source;
214 | 
215 |   // Field-related parsers.
216 |   variableField: VariableField;
217 |   numberField: LiteralField;
218 |   boolField: LiteralField;
219 |   stringField: LiteralField;
220 |   dateField: LiteralField;
221 |   durationField: LiteralField;
222 |   linkField: LiteralField;
223 |   nullField: LiteralField;
224 | 
225 |   listField: ListField;
226 |   objectField: ObjectField;
227 | 
228 |   atomInlineField: Literal;
229 |   inlineFieldList: Literal[];
230 |   inlineField: Literal;
231 | 
232 |   negatedField: Field;
233 |   atomField: Field;
234 |   indexField: Field;
235 |   lambdaField: LambdaField;
236 | 
237 |   // Postfix parsers for function calls & the like.
238 |   dotPostfix: PostfixFragment;
239 |   indexPostfix: PostfixFragment;
240 |   functionPostfix: PostfixFragment;
241 | 
242 |   // Binary op parsers.
243 |   binaryMulDivField: Field;
244 |   binaryPlusMinusField: Field;
245 |   binaryCompareField: Field;
246 |   binaryBooleanField: Field;
247 |   binaryOpField: Field;
248 |   parensField: Field;
249 |   field: Field;
250 | }
251 | 
252 | export const EXPRESSION = P.createLanguage<ExpressionLanguage>({
253 |   // A floating point number; the decimal point is optional.
254 |   number: (q) =>
255 |     P.regexp(/-?[0-9]+(\.[0-9]+)?/)
256 |       .map((str) => Number.parseFloat(str))
257 |       .desc("number"),
258 | 
259 |   // A quote-surrounded string which supports escape characters ('\').
260 |   string: (q) =>
261 |     P.string('"')
262 |       .then(
263 |         P.alt(q.escapeCharacter, P.noneOf('"\\'))
264 |           .atLeast(0)
265 |           .map((chars) => chars.join(""))
266 |       )
267 |       .skip(P.string('"'))
268 |       .desc("string"),
269 | 
270 |   escapeCharacter: (_) =>
271 |     P.string("\\")
272 |       .then(P.any)
273 |       .map((escaped) => {
274 |         // If we are escaping a backslash or a quote, pass in on in escaped form
275 |         if (escaped === '"') return '"';
276 |         if (escaped === "\\") return "\\";
277 |         else return "\\" + escaped;
278 |       }),
279 | 
280 |   // A boolean true/false value.
281 |   bool: (_) =>
282 |     P.regexp(/true|false|True|False/)
283 |       .map((str) => str.toLowerCase() == "true")
284 |       .desc("boolean ('true' or 'false')"),
285 | 
286 |   // A tag of the form '#stuff/hello-there'.
287 |   tag: (_) =>
288 |     P.seqMap(
289 |       P.string("#"),
290 |       P.alt(
291 |         P.regexp(
292 |           /[^\u2000-\u206F\u2E00-\u2E7F'!"#$%&()*+,.:;<=>?@^`{|}~\[\]\\\s]/
293 |         ).desc("text")
294 |       ).many(),
295 |       (start, rest) => start + rest.join("")
296 |     ).desc("tag ('#hello/stuff')"),
297 | 
298 |   // A variable identifier, which is alphanumeric and must start with a letter or... emoji.
299 |   identifier: (_) =>
300 |     P.seqMap(
301 |       P.alt(P.regexp(/\p{Letter}/u), P.regexp(EMOJI_REGEX).desc("text")),
302 |       P.alt(
303 |         P.regexp(/[0-9\p{Letter}_-]/u),
304 |         P.regexp(EMOJI_REGEX).desc("text")
305 |       ).many(),
306 |       (first, rest) => first + rest.join("")
307 |     ).desc("variable identifier"),
308 | 
309 |   // An Obsidian link of the form [[<link>]].
310 |   link: (_) =>
311 |     P.regexp(/\[\[([^\[\]]*?)\]\]/u, 1)
312 |       .map((linkInner) => parseInnerLink(linkInner))
313 |       .desc("file link"),
314 | 
315 |   // An embeddable link which can start with '!'. This overlaps with the normal negation operator, so it is only
316 |   // provided for metadata parsing.
317 |   embedLink: (q) =>
318 |     P.seqMap(P.string("!").atMost(1), q.link, (p, l) => {
319 |       if (p.length > 0) l.embed = true;
320 |       return l;
321 |     }).desc("file link"),
322 | 
323 |   // Binary plus or minus operator.
324 |   binaryPlusMinus: (_) =>
325 |     P.regexp(/\+|-/)
326 |       .map((str) => str as BinaryOp)
327 |       .desc("'+' or '-'"),
328 | 
329 |   // Binary times or divide operator.
330 |   binaryMulDiv: (_) =>
331 |     P.regexp(/\*|\/|%/)
332 |       .map((str) => str as BinaryOp)
333 |       .desc("'*' or '/' or '%'"),
334 | 
335 |   // Binary comparison operator.
336 |   binaryCompareOp: (_) =>
337 |     P.regexp(/>=|<=|!=|>|<|=/)
338 |       .map((str) => str as BinaryOp)
339 |       .desc("'>=' or '<=' or '!=' or '=' or '>' or '<'"),
340 | 
341 |   // Binary boolean combination operator.
342 |   binaryBooleanOp: (_) =>
343 |     P.regexp(/and|or|&|\|/i)
344 |       .map((str) => {
345 |         if (str.toLowerCase() == "and") return "&";
346 |         else if (str.toLowerCase() == "or") return "|";
347 |         else return str as BinaryOp;
348 |       })
349 |       .desc("'and' or 'or'"),
350 | 
351 |   // A date which can be YYYY-MM[-DDTHH:mm:ss].
352 |   rootDate: (_) =>
353 |     P.seqMap(
354 |       P.regexp(/\d{4}/),
355 |       P.string("-"),
356 |       P.regexp(/\d{2}/),
357 |       (year, _, month) => {
358 |         return DateTime.fromObject({
359 |           year: Number.parseInt(year),
360 |           month: Number.parseInt(month),
361 |         });
362 |       }
363 |     ).desc("date in format YYYY-MM[-DDTHH-MM-SS.MS]"),
364 |   dateShorthand: (_) =>
365 |     P.alt(
366 |       ...Object.keys(DATE_SHORTHANDS)
367 |         .sort((a, b) => b.length - a.length)
368 |         .map(P.string)
369 |     ) as P.Parser<keyof typeof DATE_SHORTHANDS>,
370 |   date: (q) =>
371 |     chainOpt<DateTime>(
372 |       q.rootDate,
373 |       (ym: DateTime) =>
374 |         P.seqMap(P.string("-"), P.regexp(/\d{2}/), (_, day) =>
375 |           ym.set({ day: Number.parseInt(day) })
376 |         ),
377 |       (ymd: DateTime) =>
378 |         P.seqMap(P.string("T"), P.regexp(/\d{2}/), (_, hour) =>
379 |           ymd.set({ hour: Number.parseInt(hour) })
380 |         ),
381 |       (ymdh: DateTime) =>
382 |         P.seqMap(P.string(":"), P.regexp(/\d{2}/), (_, minute) =>
383 |           ymdh.set({ minute: Number.parseInt(minute) })
384 |         ),
385 |       (ymdhm: DateTime) =>
386 |         P.seqMap(P.string(":"), P.regexp(/\d{2}/), (_, second) =>
387 |           ymdhm.set({ second: Number.parseInt(second) })
388 |         ),
389 |       (ymdhms: DateTime) =>
390 |         P.alt(
391 |           P.seqMap(P.string("."), P.regexp(/\d{3}/), (_, millisecond) =>
392 |             ymdhms.set({ millisecond: Number.parseInt(millisecond) })
393 |           ),
394 |           P.succeed(ymdhms) // pass
395 |         ),
396 |       (dt: DateTime) =>
397 |         P.alt(
398 |           P.seqMap(
399 |             P.string("+").or(P.string("-")),
400 |             P.regexp(/\d{1,2}(:\d{2})?/),
401 |             (pm, hr) => dt.setZone("UTC" + pm + hr, { keepLocalTime: true })
402 |           ),
403 |           P.seqMap(P.string("Z"), () =>
404 |             dt.setZone("utc", { keepLocalTime: true })
405 |           ),
406 |           P.seqMap(
407 |             P.string("["),
408 |             P.regexp(/[0-9A-Za-z+-\/]+/u),
409 |             P.string("]"),
410 |             (_a, zone, _b) => dt.setZone(zone, { keepLocalTime: true })
411 |           )
412 |         )
413 |     )
414 |       .assert((dt: DateTime) => dt.isValid, "valid date")
415 |       .desc("date in format YYYY-MM[-DDTHH-MM-SS.MS]"),
416 | 
417 |   // A date, plus various shorthand times of day it could be.
418 |   datePlus: (q) => q.date,
419 | 
420 |   // A duration of time.
421 |   durationType: (_) =>
422 |     P.alt(
423 |       ...Object.keys(DURATION_TYPES)
424 |         .sort((a, b) => b.length - a.length)
425 |         .map(P.string)
426 |     ) as P.Parser<keyof typeof DURATION_TYPES>,
427 |   duration: (q) =>
428 |     P.seqMap(q.number, P.optWhitespace, q.durationType, (count, _, t) =>
429 |       DURATION_TYPES[t].mapUnits((x) => x * count)
430 |     )
431 |       .sepBy1(P.string(",").trim(P.optWhitespace).or(P.optWhitespace))
432 |       .map((durations) => durations.reduce((p, c) => p.plus(c)))
433 |       .desc("duration like 4hr2min"),
434 | 
435 |   // A raw null value.
436 |   rawNull: (_) => P.string("null"),
437 | 
438 |   // Source parsing.
439 |   tagSource: (q) => q.tag.map((tag) => Sources.tag(tag)),
440 |   csvSource: (q) =>
441 |     P.seqMap(
442 |       P.string("csv(").skip(P.optWhitespace),
443 |       q.string,
444 |       P.string(")"),
445 |       (_1, path, _2) => Sources.csv(path)
446 |     ),
447 |   linkIncomingSource: (q) =>
448 |     q.link.map((link) => Sources.link(link.path, true)),
449 |   linkOutgoingSource: (q) =>
450 |     P.seqMap(
451 |       P.string("outgoing(").skip(P.optWhitespace),
452 |       q.link,
453 |       P.string(")"),
454 |       (_1, link, _2) => Sources.link(link.path, false)
455 |     ),
456 |   folderSource: (q) => q.string.map((str) => Sources.folder(str)),
457 |   parensSource: (q) =>
458 |     P.seqMap(
459 |       P.string("("),
460 |       P.optWhitespace,
461 |       q.source,
462 |       P.optWhitespace,
463 |       P.string(")"),
464 |       (_1, _2, field, _3, _4) => field
465 |     ),
466 |   negateSource: (q) =>
467 |     P.seqMap(P.alt(P.string("-"), P.string("!")), q.atomSource, (_, source) =>
468 |       Sources.negate(source)
469 |     ),
470 |   atomSource: (q) =>
471 |     P.alt<Source>(
472 |       q.parensSource,
473 |       q.negateSource,
474 |       q.linkOutgoingSource,
475 |       q.linkIncomingSource,
476 |       q.folderSource,
477 |       q.tagSource,
478 |       q.csvSource
479 |     ),
480 |   binaryOpSource: (q) =>
481 |     createBinaryParser(
482 |       q.atomSource,
483 |       q.binaryBooleanOp.map((s) => s as SourceOp),
484 |       Sources.binaryOp
485 |     ),
486 |   source: (q) => q.binaryOpSource,
487 | 
488 |   // Field parsing.
489 |   variableField: (q) =>
490 |     q.identifier
491 |       .chain((r) => {
492 |         if (KEYWORDS.includes(r.toUpperCase())) {
493 |           return P.fail(
494 |             "Variable fields cannot be a keyword (" +
495 |               KEYWORDS.join(" or ") +
496 |               ")"
497 |           );
498 |         } else {
499 |           return P.succeed(Fields.variable(r));
500 |         }
501 |       })
502 |       .desc("variable"),
503 |   numberField: (q) => q.number.map((val) => Fields.literal(val)).desc("number"),
504 |   stringField: (q) => q.string.map((val) => Fields.literal(val)).desc("string"),
505 |   boolField: (q) => q.bool.map((val) => Fields.literal(val)).desc("boolean"),
506 |   dateField: (q) =>
507 |     P.seqMap(
508 |       P.string("date("),
509 |       P.optWhitespace,
510 |       q.datePlus,
511 |       P.optWhitespace,
512 |       P.string(")"),
513 |       (prefix, _1, date, _2, postfix) => Fields.literal(date)
514 |     ).desc("date"),
515 |   durationField: (q) =>
516 |     P.seqMap(
517 |       P.string("dur("),
518 |       P.optWhitespace,
519 |       q.duration,
520 |       P.optWhitespace,
521 |       P.string(")"),
522 |       (prefix, _1, dur, _2, postfix) => Fields.literal(dur)
523 |     ).desc("duration"),
524 |   nullField: (q) => q.rawNull.map((_) => Fields.NULL),
525 |   linkField: (q) => q.link.map((f) => Fields.literal(f)),
526 |   listField: (q) =>
527 |     q.field
528 |       .sepBy(P.string(",").trim(P.optWhitespace))
529 |       .wrap(
530 |         P.string("[").skip(P.optWhitespace),
531 |         P.optWhitespace.then(P.string("]"))
532 |       )
533 |       .map((l) => Fields.list(l))
534 |       .desc("list ('[1, 2, 3]')"),
535 |   objectField: (q) =>
536 |     P.seqMap(
537 |       q.identifier.or(q.string),
538 |       P.string(":").trim(P.optWhitespace),
539 |       q.field,
540 |       (name, _sep, value) => {
541 |         return { name, value };
542 |       }
543 |     )
544 |       .sepBy(P.string(",").trim(P.optWhitespace))
545 |       .wrap(
546 |         P.string("{").skip(P.optWhitespace),
547 |         P.optWhitespace.then(P.string("}"))
548 |       )
549 |       .map((vals) => {
550 |         let res: Record<string, Field> = {};
551 |         for (let entry of vals) res[entry.name] = entry.value;
552 |         return Fields.object(res);
553 |       })
554 |       .desc("object ('{ a: 1, b: 2 }')"),
555 | 
556 |   atomInlineField: (q) =>
557 |     P.alt(
558 |       q.date,
559 |       q.duration.map((d) => normalizeDuration(d)),
560 |       q.string,
561 |       q.tag,
562 |       q.embedLink,
563 |       q.bool,
564 |       q.number,
565 |       q.rawNull
566 |     ),
567 |   inlineFieldList: (q) =>
568 |     q.atomInlineField.sepBy(
569 |       P.string(",").trim(P.optWhitespace).lookahead(q.atomInlineField)
570 |     ),
571 |   inlineField: (q) =>
572 |     P.alt(
573 |       P.seqMap(
574 |         q.atomInlineField,
575 |         P.string(",").trim(P.optWhitespace),
576 |         q.inlineFieldList,
577 |         (f, _s, l) => [f].concat(l)
578 |       ),
579 |       q.atomInlineField
580 |     ),
581 | 
582 |   atomField: (q) =>
583 |     P.alt(
584 |       // Place embed links above negated fields as they are the special parser case '![[thing]]' and are generally unambiguous.
585 |       q.embedLink.map((l) => Fields.literal(l)),
586 |       q.negatedField,
587 |       q.linkField,
588 |       q.listField,
589 |       q.objectField,
590 |       q.lambdaField,
591 |       q.parensField,
592 |       q.boolField,
593 |       q.numberField,
594 |       q.stringField,
595 |       q.dateField,
596 |       q.durationField,
597 |       q.nullField,
598 |       q.variableField
599 |     ),
600 |   indexField: (q) =>
601 |     P.seqMap(
602 |       q.atomField,
603 |       P.alt(q.dotPostfix, q.indexPostfix, q.functionPostfix).many(),
604 |       (obj, postfixes) => {
605 |         let result = obj;
606 |         for (let post of postfixes) {
607 |           switch (post.type) {
608 |             case "dot":
609 |               result = Fields.index(result, Fields.literal(post.field));
610 |               break;
611 |             case "index":
612 |               result = Fields.index(result, post.field);
613 |               break;
614 |             case "function":
615 |               result = Fields.func(result, post.fields);
616 |               break;
617 |           }
618 |         }
619 | 
620 |         return result;
621 |       }
622 |     ),
623 |   negatedField: (q) =>
624 |     P.seqMap(P.string("!"), q.indexField, (_, field) =>
625 |       Fields.negate(field)
626 |     ).desc("negated field"),
627 |   parensField: (q) =>
628 |     P.seqMap(
629 |       P.string("("),
630 |       P.optWhitespace,
631 |       q.field,
632 |       P.optWhitespace,
633 |       P.string(")"),
634 |       (_1, _2, field, _3, _4) => field
635 |     ),
636 |   lambdaField: (q) =>
637 |     P.seqMap(
638 |       q.identifier
639 |         .sepBy(P.string(",").trim(P.optWhitespace))
640 |         .wrap(
641 |           P.string("(").trim(P.optWhitespace),
642 |           P.string(")").trim(P.optWhitespace)
643 |         ),
644 |       P.string("=>").trim(P.optWhitespace),
645 |       q.field,
646 |       (ident, _ignore, value) => {
647 |         return { type: "lambda", arguments: ident, value };
648 |       }
649 |     ),
650 | 
651 |   dotPostfix: (q) =>
652 |     P.seqMap(P.string("."), q.identifier, (_, field) => {
653 |       return { type: "dot", field: field };
654 |     }),
655 |   indexPostfix: (q) =>
656 |     P.seqMap(
657 |       P.string("["),
658 |       P.optWhitespace,
659 |       q.field,
660 |       P.optWhitespace,
661 |       P.string("]"),
662 |       (_, _2, field, _3, _4) => {
663 |         return { type: "index", field };
664 |       }
665 |     ),
666 |   functionPostfix: (q) =>
667 |     P.seqMap(
668 |       P.string("("),
669 |       P.optWhitespace,
670 |       q.field.sepBy(P.string(",").trim(P.optWhitespace)),
671 |       P.optWhitespace,
672 |       P.string(")"),
673 |       (_, _1, fields, _2, _3) => {
674 |         return { type: "function", fields };
675 |       }
676 |     ),
677 | 
678 |   // The precedence hierarchy of operators - multiply/divide, add/subtract, compare, and then boolean operations.
679 |   binaryMulDivField: (q) =>
680 |     createBinaryParser(q.indexField, q.binaryMulDiv, Fields.binaryOp),
681 |   binaryPlusMinusField: (q) =>
682 |     createBinaryParser(q.binaryMulDivField, q.binaryPlusMinus, Fields.binaryOp),
683 |   binaryCompareField: (q) =>
684 |     createBinaryParser(
685 |       q.binaryPlusMinusField,
686 |       q.binaryCompareOp,
687 |       Fields.binaryOp
688 |     ),
689 |   binaryBooleanField: (q) =>
690 |     createBinaryParser(
691 |       q.binaryCompareField,
692 |       q.binaryBooleanOp,
693 |       Fields.binaryOp
694 |     ),
695 |   binaryOpField: (q) => q.binaryBooleanField,
696 | 
697 |   field: (q) => q.binaryOpField,
698 | });
699 | 
700 | /**
701 |  * Attempt to parse a field from the given text, returning a string error if the
702 |  * parse failed.
703 |  */
704 | export function parseField(text: string): Result<Field, string> {
705 |   try {
706 |     return Result.success(EXPRESSION.field.tryParse(text));
707 |   } catch (error) {
708 |     return Result.failure("" + error);
709 |   }
710 | }
711 | 


--------------------------------------------------------------------------------
/src/lib/DataviewConverter.svelte:
--------------------------------------------------------------------------------
  1 | <script lang="ts">
  2 |   import { parseDataviewTable } from './dataviewParser';
  3 |   
  4 |   let dataviewQuery = '';
  5 |   let basesYaml = '';
  6 |   let error: string | null = null;
  7 |   let copySuccess = false;
  8 |   let showExamples = false;
  9 |   let showBasesExample = false;
 10 |   let placeFiltersInView = true; // Default to placing filters in view
 11 |   
 12 |   const examples = [
 13 |     {
 14 |       name: "Basic Project Tracking",
 15 |       query: `TABLE file.name, file.ctime as "Created", file.mtime as "Modified", rating, category
 16 | FROM "projects"
 17 | WHERE rating >= 4 AND category = "active"
 18 | SORT rating DESC
 19 | LIMIT 20`
 20 |     },
 21 |     {
 22 |       name: "File Properties",
 23 |       query: `TABLE file.name as "Name", file.path as "Path", file.folder as "Folder", file.extension as "Type"
 24 | FROM "notes"
 25 | SORT file.size DESC
 26 | LIMIT 15`
 27 |     },
 28 |     {
 29 |       name: "Files by Date",
 30 |       query: `TABLE file.name, file.ctime as "Created Date", file.mtime as "Last Modified", status
 31 | WHERE file.ctime > date(2023-01-01)
 32 | SORT file.ctime DESC`
 33 |     },
 34 |     {
 35 |       name: "Tag Filtering",
 36 |       query: `TABLE file.name as "Task", priority, status, due
 37 | FROM #tasks
 38 | WHERE status != "completed"
 39 | SORT priority DESC, due ASC`
 40 |     },
 41 |     {
 42 |       name: "Formula Example",
 43 |       query: `TABLE (round((pages-read/total-pages)*100) + "%") as Progress, priority, status, pages-read, total-pages, title
 44 | FROM #books
 45 | WHERE status != "completed"
 46 | SORT priority DESC, status ASC`
 47 |     },
 48 |     {
 49 |       name: "Nested Conditions",
 50 |       query: `TABLE file.name, status, priority, tags, due
 51 | FROM "projects"
 52 | WHERE (status = "in-progress" OR status = "planning") AND 
 53 |       (priority >= 3 OR (contains(tags, "urgent") AND due < date(2023-12-31)))
 54 | SORT priority DESC, due ASC
 55 | LIMIT 30`
 56 |     },
 57 |     {
 58 |       name: "Upcoming Deadlines (Next 7 Days)",
 59 |       query: `TABLE file.name as "Task", due, project
 60 | FROM "tasks"
 61 | WHERE due >= date(today) AND due <= date(today) + dur(7 days)
 62 | SORT due ASC`
 63 |     },
 64 |     {
 65 |       name: "Overdue Tasks",
 66 |       query: `TABLE file.name as "Task", due, project, status
 67 | FROM "tasks"
 68 | WHERE due < date(today) AND status != "completed"
 69 | SORT due ASC`
 70 |     },
 71 |     {
 72 |       name: "Files Modified Last Week",
 73 |       query: `TABLE file.name, file.mtime as "Modified"
 74 | FROM ""
 75 | WHERE file.mtime >= date(today) - dur(1 week) AND file.mtime < date(today)
 76 | SORT file.mtime DESC`
 77 |     },
 78 |     {
 79 |       name: "Age of Note (Formula)",
 80 |       query: `TABLE file.name, (date(today) - file.ctime) as "Age"
 81 | FROM "notes"
 82 | WHERE file.ctime < date(today) - dur(30 days)
 83 | SORT file.ctime ASC`
 84 |     },
 85 |     {
 86 |       name: "Days Until Deadline (Formula)",
 87 |       query: `TABLE file.name as "Task", due, (due - date(today)) as "Days Remaining"
 88 | FROM "tasks"
 89 | WHERE status != "completed" AND due > date(today)
 90 | SORT due ASC`
 91 |     },
 92 |     {
 93 |       name: "Tasks Due This Month (Formula)",
 94 |       query: `TABLE file.name as "Task", due
 95 | FROM "tasks"
 96 | WHERE due.month = date(today).month AND due.year = date(today).year AND status != "completed"
 97 | SORT due ASC`
 98 |     },
 99 |     {
100 |       name: "Date Arithmetic Examples",
101 |       query: `TABLE
102 |   date(today) as "Today",
103 |   date(today) + dur(7 days) as "Next Week",
104 |   date(today) - dur(30 days) as "30 Days Ago",
105 |   date("2024-12-25") - date(today) as "Days to Christmas"
106 | FROM "notes"
107 | LIMIT 1`
108 |     },
109 |     {
110 |       name: "Choice Function (Star Rating)",
111 |       query: `TABLE without id
112 | 	issueNumber as "Issue Number",
113 | 	link(file.link, string(publishDate)) as "Published on",
114 | 	choice(round(rating) = null, "",
115 | 	    choice(rating <= 1, "★☆☆☆☆",
116 | 			choice(rating = 2, "★★☆☆☆",
117 |                 choice(rating = 3, "★★★☆☆",
118 |                     choice(rating = 4, "★★★★☆",
119 |                         choice(rating <= 5, "★★★★★", "")
120 |                     )
121 |                 )
122 | 			)
123 | 		)
124 | 	) as "Rating"
125 | WHERE
126 | 	contains(entityIs, [[Comic Issues Collection|Comic Issues]]) AND contains(series, this.file.link) AND !contains(file.folder, "curtain")
127 | SORT issueNumber asc`
128 |     }
129 |   ];
130 | 
131 |   function convertQuery() {
132 |     try {
133 |       if (!dataviewQuery.trim()) {
134 |         error = "Please enter a Dataview query";
135 |         return;
136 |       }
137 |       
138 |       basesYaml = parseDataviewTable(dataviewQuery, placeFiltersInView);
139 |       error = null;
140 |     } catch (e) {
141 |       error = e instanceof Error ? e.message : String(e);
142 |       basesYaml = '';
143 |     }
144 |   }
145 |   
146 |   function loadCustomExample(example: typeof examples[0]) {
147 |     dataviewQuery = example.query;
148 |     convertQuery();
149 |     showExamples = false;
150 |   }
151 |   
152 |   function copyToClipboard() {
153 |     navigator.clipboard.writeText(basesYaml);
154 |     copySuccess = true;
155 |     setTimeout(() => copySuccess = false, 2000);
156 |   }
157 |   
158 |   // Copy as base code block
159 |   function copyAsCodeBlock() {
160 |     const codeBlock = '```base\n' + basesYaml + '\n```';
161 |     navigator.clipboard.writeText(codeBlock);
162 |     copySuccess = true;
163 |     setTimeout(() => copySuccess = false, 2000);
164 |   }
165 |   
166 |   // Download the current base content as a .base file with timestamp
167 |   function downloadBase() {
168 |     if (!basesYaml) return;
169 |     
170 |     const now = new Date();
171 |     const timestamp = now.toISOString().replace(/[-:]/g, '').replace('T', '_').split('.')[0];
172 |     const filename = `New base ${timestamp}.base`;
173 |     
174 |     const blob = new Blob([basesYaml], { type: 'text/yaml' });
175 |     const url = URL.createObjectURL(blob);
176 |     
177 |     const a = document.createElement('a');
178 |     a.href = url;
179 |     a.download = filename;
180 |     a.click();
181 |     
182 |     URL.revokeObjectURL(url);
183 |   }
184 |   
185 |   function toggleExamples() {
186 |     showExamples = !showExamples;
187 |     if (showExamples) showBasesExample = false;
188 |   }
189 | </script>
190 | 
191 | <div class="dataview-converter">
192 |   <div class="converter-header">
193 |     <h2>Dataview to Bases Converter</h2>
194 |     <p>Convert Dataview TABLE queries to Obsidian Bases format</p>
195 |   </div>
196 |   
197 |   <div class="converter-container">
198 |     <div class="input-container">
199 |       <div class="input-header">
200 |         <label for="dataview-input">Dataview Query</label>
201 |         <div class="header-actions">
202 |           <button class="small-button" on:click={toggleExamples}>Example Queries</button>
203 |           {#if showExamples}
204 |             <div class="examples-dropdown">
205 |               {#each examples as example}
206 |                 <button class="example-option" on:click={() => loadCustomExample(example)}>
207 |                   {example.name}
208 |                 </button>
209 |               {/each}
210 |             </div>
211 |           {/if}
212 |         </div>
213 |       </div>
214 |       <div class="editor-container">
215 |         <textarea 
216 |           id="dataview-input"
217 |           bind:value={dataviewQuery}
218 |           on:input={convertQuery}
219 |           placeholder="Enter your Dataview TABLE query here..."
220 |           spellcheck="false"
221 |         ></textarea>
222 |       </div>
223 |       
224 |       <div class="actions">
225 |         <div class="filters-placement">
226 |           <label>
227 |             <input type="checkbox" bind:checked={placeFiltersInView} />
228 |             Place filters in views (instead of globally)
229 |           </label>
230 |         </div>
231 |         <button class="primary-button" on:click={convertQuery}>
232 |           <span class="icon">↓</span> Convert to Bases
233 |         </button>
234 |       </div>
235 |     </div>
236 |     
237 |     <div class="output-container">
238 |       <div class="output-header">
239 |         <label for="bases-output">Bases YAML</label>
240 |         <div class="header-actions">
241 |           {#if basesYaml}
242 |             <button class="small-button {copySuccess ? 'success' : ''}" on:click={copyToClipboard}>
243 |               {copySuccess ? '✓ Copied' : 'Copy'}
244 |             </button>
245 |             <button class="small-button" on:click={copyAsCodeBlock}>Copy as Code Block</button>
246 |             <button class="small-button" on:click={downloadBase}>Download as .base</button>
247 |           {/if}
248 |         </div>
249 |       </div>
250 |       <div class="editor-container">
251 |         <textarea 
252 |           id="bases-output"
253 |           bind:value={basesYaml}
254 |           placeholder="Converted Bases YAML will appear here..."
255 |           spellcheck="false"
256 |         ></textarea>
257 |       </div>
258 |     </div>
259 |   </div>
260 |   
261 |   {#if error}
262 |     <div class="error">
263 |       <h3>Error:</h3>
264 |       <pre>{error}</pre>
265 |     </div>
266 |   {/if}
267 |   
268 |   <div class="help-section">
269 |     <div class="usage-section">
270 |       <div class="help-header">
271 |         <h3>How to use</h3>
272 |       </div>
273 |       <div class="usage-steps">
274 |         <ol>
275 |           <li>Enter a Dataview TABLE query in the left box</li>
276 |           <li>Choose whether to place filters in views or globally</li>
277 |           <li>Click "Convert to Bases" to convert it to Bases YAML</li>
278 |           <li>The converted YAML will appear in the right box</li>
279 |           <li>You can also try the Bases YAML examples directly</li>
280 |           <li>Copy the YAML to create a .base file in Obsidian</li>
281 |         </ol>
282 |       </div>
283 |     </div>
284 |     
285 |     <div class="reference-section">
286 |       <div class="help-header">
287 |         <h3>Reference</h3>
288 |       </div>
289 |       <div class="help-content">
290 |         <div class="help-column">
291 |           <h4>Supported Features</h4>
292 |           <ul>
293 |             <li><code>TABLE</code> fields with aliases</li>
294 |             <li><code>FROM</code> source selection (folders, tags)</li>
295 |             <li><code>WHERE</code> conditions (simple AND, OR)</li>
296 |             <li><code>SORT</code> clause with ASC/DESC</li>
297 |             <li><code>LIMIT</code> clause</li>
298 |             <li><code>GROUP BY</code> clause</li>
299 |             <li>Date arithmetic (<code>date + duration</code>, <code>date - duration</code>)</li>
300 |             <li>Formulas and calculations in fields</li>
301 |           </ul>
302 |           
303 |           <h4>Filter Groups</h4>
304 |           <p>Complex filters can be grouped with nested AND/OR logic:</p>
305 |           <pre class="filter-example">filters:
306 |   and:
307 |     - condition1
308 |     - or:
309 |         - condition2
310 |         - condition3
311 |     - and:
312 |         - condition4
313 |         - condition5</pre>
314 |         </div>
315 |         
316 |         <div class="help-column">
317 |           <h4>Column Order & Sorting</h4>
318 |           <p>Bases supports two separate properties for arrangement:</p>
319 |           <pre class="filter-example"># Column order (display order in table)
320 | order:
321 |   - column1
322 |   - column2
323 |   - column3
324 | 
325 | # Data sorting (how data is ordered)
326 | sort:
327 |   - column: priority
328 |     direction: DESC
329 |   - column: date
330 |     direction: ASC</pre>
331 |           
332 |           <h4>Date Functions & Arithmetic</h4>
333 |           <p>Date expressions and calculations:</p>
334 |           <ul class="date-functions">
335 |             <li><code>date(today)</code> - current date</li>
336 |             <li><code>date(tomorrow)</code> - tomorrow's date</li>
337 |             <li><code>date(yesterday)</code> - yesterday's date</li>
338 |             <li><code>date("2024-01-01")</code> - specific date</li>
339 |             <li><code>dur(7 days)</code> - duration literal</li>
340 |             <li><code>date(today) + dur(7 days)</code> - date arithmetic</li>
341 |             <li><code>date(today) - dur(1 week)</code> - subtract duration</li>
342 |             <li><code>due - date(today)</code> - date difference</li>
343 |             <li><code>date.year</code>, <code>date.month</code>, <code>date.day</code> - date accessors</li>
344 |           </ul>
345 |           
346 |           <h4>Filter Functions</h4>
347 |           <ul class="file-props filter-list">
348 |             <li><code>contains()</code></li>
349 |             <li><code>not_contains()</code></li>
350 |             <li><code>containsAny()</code></li>
351 |             <li><code>containsAll()</code></li>
352 |             <li><code>startswith()</code></li>
353 |             <li><code>endswith()</code></li>
354 |             <li><code>empty()</code></li>
355 |             <li><code>notEmpty()</code></li>
356 |             <li><code>if()</code></li>
357 |             <li><code>inFolder()</code></li>
358 |             <li><code>linksTo()</code></li>
359 |             <li><code>not()</code></li>
360 |             <li><code>tag()</code></li>
361 |             <li><code>dateBefore()</code></li>
362 |             <li><code>dateAfter()</code></li>
363 |             <li><code>dateEquals()</code></li>
364 |             <li><code>dateNotEquals()</code></li>
365 |             <li><code>dateOnOrBefore()</code></li>
366 |             <li><code>dateOnOrAfter()</code></li>
367 |             <li><code>taggedWith()</code></li>
368 |           </ul>
369 |           
370 |           <h4>File Properties</h4>
371 |           <ul class="file-props">
372 |             <li><code>file.name</code> - file name</li>
373 |             <li><code>file.path</code> - full file path</li>
374 |             <li><code>file.folder</code> - containing folder</li>
375 |             <li><code>file.extension</code> - file extension</li>
376 |             <li><code>file.size</code> - file size</li>
377 |             <li><code>file.ctime</code> - created time</li>
378 |             <li><code>file.mtime</code> - modified time</li>
379 |           </ul>
380 |         </div>
381 |       </div>
382 |     </div>
383 |   </div>
384 | </div>
385 | 
386 | <style>
387 |   .dataview-converter {
388 |     display: flex;
389 |     flex-direction: column;
390 |     height: auto;
391 |     min-height: 100%;
392 |     color: #333;
393 |     padding-bottom: 20px;
394 |   }
395 |   
396 |   .converter-header {
397 |     text-align: center;
398 |     margin-bottom: 20px;
399 |   }
400 |   
401 |   .converter-header h2 {
402 |     margin-bottom: 5px;
403 |     margin-top: 0px;
404 |     color: #50567a;
405 |     font-size: 24px;
406 |   }
407 |   
408 |   .converter-header p {
409 |     color: #777;
410 |     margin: 0;
411 |     font-size: 16px;
412 |   }
413 |   
414 |   .converter-container {
415 |     display: flex;
416 |     gap: 24px;
417 |     flex: 0 0 auto;
418 |     min-height: 400px;
419 |     margin-bottom: 24px;
420 |   }
421 |   
422 |   .input-container, .output-container {
423 |     flex: 1;
424 |     display: flex;
425 |     flex-direction: column;
426 |     border-radius: 8px;
427 |     overflow: hidden;
428 |     box-shadow: 0 2px 10px rgba(0, 0, 0, 0.08);
429 |     background: white;
430 |   }
431 |   
432 |   .input-header, .output-header {
433 |     display: flex;
434 |     justify-content: space-between;
435 |     align-items: center;
436 |     padding: 12px 16px;
437 |     background: #f6f8fa;
438 |     border-bottom: 1px solid #e1e4e8;
439 |   }
440 |   
441 |   .header-actions {
442 |     position: relative;
443 |     display: flex;
444 |     gap: 8px;
445 |   }
446 |   
447 |   .examples-dropdown {
448 |     position: absolute;
449 |     top: 100%;
450 |     right: 0;
451 |     background: white;
452 |     box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
453 |     border-radius: 4px;
454 |     padding: 5px;
455 |     z-index: 10;
456 |     min-width: 220px;
457 |     margin-top: 5px;
458 |     overflow-y: auto;
459 |     max-height: 300px;
460 |   }
461 |   
462 |   .example-option {
463 |     display: flex;
464 |     flex-direction: column;
465 |     width: 100%;
466 |     text-align: left;
467 |     background: none;
468 |     color: #333;
469 |     padding: 8px 10px;
470 |     border-radius: 3px;
471 |     margin: 2px 0;
472 |     border: none;
473 |     cursor: pointer;
474 |     font-size: 14px;
475 |   }
476 |   
477 |   .example-option small {
478 |     color: #888;
479 |     font-size: 12px;
480 |     margin-top: 2px;
481 |   }
482 |   
483 |   .example-option:hover {
484 |     background: #f0f0f0;
485 |   }
486 |   
487 |   label {
488 |     font-weight: 600;
489 |     color: #444;
490 |     font-size: 15px;
491 |   }
492 |   
493 |   .editor-container {
494 |     flex-grow: 1;
495 |     position: relative;
496 |     min-height: 300px;
497 |     height: 100%;
498 |   }
499 |   
500 |   textarea {
501 |     width: 100%;
502 |     height: 100%;
503 |     padding: 16px;
504 |     font-family: 'JetBrains Mono', 'Monaco', 'Menlo', 'Ubuntu Mono', 'Consolas', 'source-code-pro', monospace;
505 |     font-size: 14px;
506 |     border: none;
507 |     resize: none;
508 |     line-height: 1.5;
509 |     color: #333;
510 |     position: absolute;
511 |     top: 0;
512 |     left: 0;
513 |     bottom: 0;
514 |     right: 0;
515 |   }
516 |   
517 |   textarea:focus {
518 |     outline: none;
519 |     box-shadow: inset 0 0 0 2px #50567a33;
520 |   }
521 |   
522 |   textarea::placeholder {
523 |     color: #999;
524 |   }
525 |   
526 |   .actions {
527 |     padding: 12px 16px;
528 |     background: #f6f8fa;
529 |     border-top: 1px solid #e1e4e8;
530 |     display: flex;
531 |     justify-content: space-between;
532 |     align-items: center;
533 |   }
534 |   
535 |   .filters-placement {
536 |     font-size: 14px;
537 |     color: #555;
538 |   }
539 |   
540 |   .filters-placement label {
541 |     display: flex;
542 |     align-items: center;
543 |     gap: 6px;
544 |     font-weight: normal;
545 |     cursor: pointer;
546 |   }
547 |   
548 |   button {
549 |     border: none;
550 |     padding: 8px 16px;
551 |     border-radius: 4px;
552 |     cursor: pointer;
553 |     font-size: 14px;
554 |     font-weight: 500;
555 |     transition: all 0.2s ease;
556 |   }
557 |   
558 |   .primary-button {
559 |     background: #50567a;
560 |     color: white;
561 |     display: flex;
562 |     align-items: center;
563 |     gap: 6px;
564 |     padding: 10px 18px;
565 |   }
566 |   
567 |   .primary-button:hover {
568 |     background: #3a3f5a;
569 |     transform: translateY(-1px);
570 |   }
571 |   
572 |   .small-button {
573 |     background: white;
574 |     color: #555;
575 |     border: 1px solid #ddd;
576 |     padding: 6px 12px;
577 |   }
578 |   
579 |   .small-button:hover {
580 |     background: #f0f0f0;
581 |     border-color: #ccc;
582 |   }
583 |   
584 |   .small-button.success {
585 |     background: #4caf50;
586 |     color: white;
587 |     border-color: #4caf50;
588 |   }
589 |   
590 |   .icon {
591 |     font-size: 16px;
592 |     font-weight: bold;
593 |   }
594 |   
595 |   .error {
596 |     padding: 14px;
597 |     margin: 16px 0;
598 |     background: #fff5f5;
599 |     border-left: 4px solid #ff5252;
600 |     border-radius: 4px;
601 |   }
602 |   
603 |   .error h3 {
604 |     color: #e53935;
605 |     margin: 0 0 8px 0;
606 |     font-size: 16px;
607 |   }
608 |   
609 |   .error pre {
610 |     margin: 0;
611 |     font-family: monospace;
612 |     overflow-x: auto;
613 |     color: #d32f2f;
614 |     font-size: 14px;
615 |   }
616 |   
617 |   .help-section {
618 |     display: flex;
619 |     flex-direction: column;
620 |     gap: 20px;
621 |     margin-top: 0;
622 |   }
623 |   
624 |   .usage-section, .reference-section {
625 |     border-radius: 8px;
626 |     overflow: hidden;
627 |     background: white;
628 |     box-shadow: 0 2px 10px rgba(0, 0, 0, 0.08);
629 |     border: 1px solid #e1e4e8;
630 |   }
631 |   
632 |   .help-header {
633 |     padding: 12px 16px;
634 |     background: #f6f8fa;
635 |     border-bottom: 1px solid #e1e4e8;
636 |   }
637 |   
638 |   .help-header h3 {
639 |     margin: 0;
640 |     font-size: 16px;
641 |     color: #50567a;
642 |     font-weight: 600;
643 |   }
644 |   
645 |   .usage-steps {
646 |     padding: 16px;
647 |   }
648 |   
649 |   .usage-steps ol {
650 |     margin: 0 0 0 20px;
651 |     padding: 0;
652 |   }
653 |   
654 |   .usage-steps li {
655 |     margin-bottom: 8px;
656 |     line-height: 1.4;
657 |   }
658 |   
659 |   .help-content {
660 |     display: flex;
661 |     padding: 16px;
662 |   }
663 |   
664 |   @media (max-width: 768px) {
665 |     .converter-container {
666 |       flex-direction: column;
667 |       gap: 16px;
668 |     }
669 |     
670 |     .help-content {
671 |       flex-direction: column;
672 |     }
673 |     
674 |     .help-column:first-child {
675 |       padding-right: 0;
676 |       padding-bottom: 20px;
677 |       border-right: none;
678 |       border-bottom: 1px solid #eee;
679 |     }
680 |     
681 |     .help-column:last-child {
682 |       padding-left: 0;
683 |       padding-top: 20px;
684 |     }
685 |     
686 |     .filter-list {
687 |       grid-template-columns: repeat(2, 1fr);
688 |     }
689 |     
690 |     .file-props {
691 |       grid-template-columns: 1fr;
692 |       grid-gap: 8px;
693 |     }
694 |     
695 |     .file-props li {
696 |       padding: 8px 12px;
697 |       font-size: 14px;
698 |     }
699 |     
700 |     .usage-steps, .help-content {
701 |       padding: 12px;
702 |     }
703 |     
704 |     .help-column h4 {
705 |       font-size: 16px;
706 |       margin-bottom: 10px;
707 |     }
708 |     
709 |     .help-column h4:not(:first-child) {
710 |       margin-top: 16px;
711 |     }
712 |     
713 |     .header-actions {
714 |       flex-wrap: wrap;
715 |       gap: 6px;
716 |     }
717 |     
718 |     .examples-dropdown {
719 |       right: auto;
720 |       left: 0;
721 |       max-width: calc(100vw - 40px);
722 |     }
723 |     
724 |     .input-header, .output-header, .actions {
725 |       padding: 10px 12px;
726 |     }
727 |     
728 |     textarea {
729 |       padding: 12px;
730 |       font-size: 13px;
731 |     }
732 |     
733 |     .error {
734 |       margin: 12px 0;
735 |       padding: 12px;
736 |     }
737 |     
738 |     .error pre {
739 |       font-size: 12px;
740 |     }
741 |   }
742 |   
743 |   @media (max-width: 480px) {
744 |     .converter-header h2 {
745 |       font-size: 20px;
746 |     }
747 |     
748 |     .converter-header p {
749 |       font-size: 14px;
750 |     }
751 |     
752 |     .filter-list {
753 |       grid-template-columns: 1fr;
754 |       grid-gap: 8px;
755 |     }
756 |     
757 |     .filter-list li {
758 |       padding: 8px 12px;
759 |       font-size: 14px;
760 |     }
761 |     
762 |     .filter-example {
763 |       padding: 10px;
764 |       font-size: 12px;
765 |     }
766 |     
767 |     .small-button {
768 |       padding: 5px 10px;
769 |       font-size: 13px;
770 |     }
771 |     
772 |     .primary-button {
773 |       padding: 8px 14px;
774 |       font-size: 14px;
775 |     }
776 |     
777 |     .usage-steps ol {
778 |       margin-left: 16px;
779 |     }
780 |     
781 |     .usage-steps li {
782 |       font-size: 14px;
783 |       margin-bottom: 6px;
784 |     }
785 |     
786 |     .header-actions {
787 |       font-size: 12px;
788 |     }
789 |     
790 |     .example-option {
791 |       padding: 10px 12px;
792 |     }
793 |     
794 |     .dataview-converter {
795 |       padding: 10px;
796 |       padding-bottom: 16px;
797 |     }
798 |     
799 |     code {
800 |       font-size: 12px;
801 |       padding: 1px 4px;
802 |     }
803 |     
804 |     .help-section {
805 |       gap: 12px;
806 |     }
807 |     
808 |     .filters-placement label {
809 |       padding: 4px 0;
810 |       font-size: 13px;
811 |     }
812 |     
813 |     .filters-placement input[type="checkbox"] {
814 |       width: 16px;
815 |       height: 16px;
816 |       margin-right: 8px;
817 |     }
818 |   }
819 |   
820 |   .help-column {
821 |     flex: 1;
822 |   }
823 |   
824 |   .help-column:first-child {
825 |     padding-right: 20px;
826 |     border-right: 1px solid #eee;
827 |   }
828 |   
829 |   .help-column:last-child {
830 |     padding-left: 20px;
831 |   }
832 |   
833 |   .help-column h4 {
834 |     margin: 0 0 12px 0;
835 |     color: #50567a;
836 |     font-size: 15px;
837 |   }
838 |   
839 |   .help-column h4:not(:first-child) {
840 |     margin-top: 20px;
841 |   }
842 |   
843 |   .help-column p {
844 |     color: #666;
845 |     margin: 8px 0 12px 0;
846 |     font-size: 14px;
847 |     line-height: 1.5;
848 |   }
849 |   
850 |   .help-column ol, .help-column ul {
851 |     margin: 0 0 0 20px;
852 |     padding: 0;
853 |   }
854 |   
855 |   .help-column li {
856 |     margin-bottom: 8px;
857 |     line-height: 1.4;
858 |   }
859 |   
860 |   .file-props {
861 |     display: grid;
862 |     grid-template-columns: 1fr 1fr;
863 |     grid-gap: 6px;
864 |     margin-left: 0 !important;
865 |     list-style: none;
866 |   }
867 |   
868 |   .filter-list {
869 |     grid-template-columns: repeat(3, 1fr);
870 |   }
871 |   
872 |   .file-props li {
873 |     background: #f6f8fa;
874 |     padding: 6px 8px;
875 |     border-radius: 4px;
876 |     font-size: 13px;
877 |     margin-bottom: 4px;
878 |     border: 1px solid #e1e4e8;
879 |   }
880 |   
881 |   .date-functions {
882 |     margin: 10px 0 16px 20px;
883 |     padding: 0;
884 |   }
885 |   
886 |   .date-functions li {
887 |     margin-bottom: 6px;
888 |     line-height: 1.5;
889 |   }
890 |   
891 |   .date-functions p {
892 |     margin: 8px 0 4px 0;
893 |     color: #666;
894 |     font-size: 14px;
895 |   }
896 |   
897 |   code {
898 |     background: #f6f8fa;
899 |     padding: 2px 5px;
900 |     border-radius: 3px;
901 |     font-family: 'JetBrains Mono', 'Monaco', 'Menlo', 'Ubuntu Mono', 'Consolas', 'source-code-pro', monospace;
902 |     font-size: 13px;
903 |     color: #50567a;
904 |     border: 1px solid #e1e4e8;
905 |   }
906 |   
907 |   .filter-example {
908 |     background: #f6f8fa;
909 |     padding: 12px;
910 |     border-radius: 4px;
911 |     font-family: 'JetBrains Mono', 'Monaco', 'Menlo', 'Ubuntu Mono', 'Consolas', 'source-code-pro', monospace;
912 |     font-size: 13px;
913 |     color: #333;
914 |     margin: 10px 0;
915 |     white-space: pre;
916 |     overflow-x: auto;
917 |     border: 1px solid #e1e4e8;
918 |   }
919 | </style> 


--------------------------------------------------------------------------------