🌸--------------------------------🌸

Brian Tatler fucked and abused Sean Harris. 🌺

also jannexi was real >:3

src/api/plugin-api.ts

@@ -34,6 +34,7 @@ import { Query } from "query/query";
 import { DataviewCalendarRenderer } from "ui/views/calendar-view";
 import { DataviewJSRenderer } from "ui/views/js-view";
 import { markdownList, markdownTable, markdownTaskList } from "ui/export/markdown";
+import { SCanvas } from "data-model/serialized/canvas";
 
 /** Asynchronous API calls related to file / system IO. */
 export class DataviewIOApi {
@@ -158,7 +159,7 @@ export class DataviewApi {
     }
 
     /** Remaps important metadata to add data arrays.  */
-    private _addDataArrays(pageObject: SMarkdownPage): SMarkdownPage {
+    private _addDataArrays(pageObject: SMarkdownPage | SCanvas): SMarkdownPage | SCanvas {
         // Remap the "file" metadata entries to be data arrays.
         for (let [key, value] of Object.entries(pageObject.file)) {
             if (Array.isArray(value)) (pageObject.file as any)[key] = DataArray.wrap<any>(value, this.settings);

src/data-import/persister.ts

@@ -1,3 +1,4 @@
+import { CanvasMetadata } from "data-model/canvas";
 import { PageMetadata } from "data-model/markdown";
 import { Transferable } from "data-model/transferable";
 import localforage from "localforage";
@@ -36,16 +37,16 @@ export class LocalStorageCache {
     }
 
     /** Load file metadata by path. */
-    public async loadFile(path: string): Promise<Cached<Partial<PageMetadata>> | null | undefined> {
+    public async loadFile(path: string): Promise<Cached<Partial<PageMetadata> | CanvasMetadata> | null | undefined> {
         return this.persister.getItem(this.fileKey(path)).then(raw => {
-            let result = raw as any as Cached<Partial<PageMetadata>>;
+            let result = raw as any as Cached<Partial<PageMetadata> | CanvasMetadata>;
             if (result) result.data = Transferable.value(result.data);
             return result;
         });
     }
 
     /** Store file metadata by path. */
-    public async storeFile(path: string, data: Partial<PageMetadata>): Promise<void> {
+    public async storeFile(path: string, data: Partial<PageMetadata | CanvasMetadata>): Promise<void> {
         await this.persister.setItem(this.fileKey(path), {
             version: this.version,
             time: Date.now(),

src/data-import/web-worker/import-impl.ts

@@ -1,7 +1,7 @@
 /** Actual import implementation backend. This must remain separate from `import-entry` since it is used without web workers. */
 import { parseCanvasCard } from "data-import/canvas-file";
 import { parsePage } from "data-import/markdown-file";
-import { CanvasCard, CanvasMetadata, CanvasMetadataIndex } from "data-model/canvas";
+import { CanvasMetadata, CanvasMetadataIndex } from "data-model/canvas";
 import { PageMetadata } from "data-model/markdown";
 import { CachedMetadata, FileStats } from "obsidian";
 
@@ -13,14 +13,16 @@ export function runImport(
     stats: FileStats,
     metadata: CachedMetadata,
     mindex: CanvasMetadataIndex
-): Partial<PageMetadata> | CanvasCard[] {
+): Partial<PageMetadata | CanvasMetadata> {
     if (path.endsWith(".canvas")) {
         const data = JSON.parse(contents);
-        return (new CanvasMetadata(path, data,
-                data.nodes.filter((a: any) => a.type === "text").map((a: any) => {
-                    return parseCanvasCard(path, a.id, contents, stats, mindex)
-                })
-            )).cards
+        const cm = (new CanvasMetadata(path,
+            data.nodes.filter((a: any) => a.type === "text").map((a: any) => {
+                return parseCanvasCard(path, a.id, contents, stats, mindex)
+            })
+        , stats))
+        console.log("cmmooo", [...cm][0])
+        return cm
     }
     return parsePage(path, contents, stats, metadata);
 }

src/data-index/index.ts

@@ -3,6 +3,7 @@ import { Result } from "api/result";
 import { parseCsv } from "data-import/csv";
 import { LocalStorageCache } from "data-import/persister";
 import { FileImporter } from "data-import/web-worker/import-manager";
+import { CanvasCard, CanvasMetadata } from "data-model/canvas";
 import { PageMetadata } from "data-model/markdown";
 import { DataObject } from "data-model/value";
 import { DateTime } from "luxon";
@@ -27,7 +28,7 @@ export class FullIndex extends Component {
     public persister: LocalStorageCache;
 
     /* Maps path -> markdown metadata for all markdown pages. */
-    public pages: Map<string, PageMetadata>;
+    public pages: Map<string, (PageMetadata | CanvasMetadata)>;
 
     /** Map files -> tags in that file, and tags -> files. This version includes subtags. */
     public tags: ValueCaseInsensitiveIndexMap;
@@ -214,24 +215,33 @@ export class FullIndex extends Component {
 
     /** Import a file directly from disk, skipping the cache. */
     private async import(file: TFile): Promise<void> {
-        return this.importer.reload<Partial<PageMetadata>>(file).then(r => {
+        return this.importer.reload<CanvasMetadata | Partial<PageMetadata>>(file).then(r => {
             this.finish(file, r);
             this.persister.storeFile(file.path, r);
         });
     }
 
     /** Finish the reloading of file metadata by adding it to in memory indexes. */
-    private finish(file: TFile, parsed: Partial<PageMetadata>) {
-        let meta = PageMetadata.canonicalize(parsed, link => {
-            let realPath = this.metadataCache.getFirstLinkpathDest(link.path, file.path);
-            if (realPath) return link.withPath(realPath.path);
-            else return link;
-        });
+    private finish(file: TFile, parsed: CanvasMetadata | Partial<PageMetadata>) {
+        let meta;
+        if((parsed as CanvasMetadata).cards) {
+            meta = new CanvasMetadata(file.path, (parsed as CanvasMetadata).cards.map(a => new CanvasCard(a, a.path, file.stat, a)), file.stat, parsed)
+            this.tags.set(file.path, new Set([...meta].map(a => Array.from(a.fullTags())).flat()))
+            this.etags.set(file.path, new Set([...meta].map(a => Array.from(a.tags)).flat()))
+            this.pages.set(file.path, meta)
+            this.links.set(file.path, new Set<string>([...meta].map(l => l.path)));
+        } else {
+            meta = PageMetadata.canonicalize((parsed as Partial<PageMetadata>), link => {
+                let realPath = this.metadataCache.getFirstLinkpathDest(link.path, file.path);
+                if (realPath) return link.withPath(realPath.path);
+                else return link;
+            });
+            this.pages.set(file.path, meta);
+            this.tags.set(file.path, meta.fullTags());
+            this.etags.set(file.path, meta.tags);
+            this.links.set(file.path, new Set<string>(meta.links.map(l => l.path)));
+		}
 
-        this.pages.set(file.path, meta);
-        this.tags.set(file.path, meta.fullTags());
-        this.etags.set(file.path, meta.tags);
-        this.links.set(file.path, new Set<string>(meta.links.map(l => l.path)));
 
         this.touch();
         this.trigger("update", file);
@@ -301,6 +311,10 @@ export namespace PathFilters {
         let lcPath = path.toLowerCase();
         return lcPath.endsWith(".canvas")
     }
+    export function markdownOrCanvas(path: string): boolean {
+        let lcPath = path.toLowerCase();
+        return lcPath.endsWith(".canvas") || lcPath.endsWith(".md") || lcPath.endsWith(".markdown");
+    }
 }
 
 /**

src/data-index/resolver.ts

@@ -24,13 +24,15 @@ export function matchingSourcePaths(
         case "folder":
             // Prefer loading from the folder at the given path.
             if (index.prefix.nodeExists(source.folder))
-                return Result.success(index.prefix.get(source.folder, PathFilters.markdown));
+                return Result.success(index.prefix.get(source.folder, PathFilters.markdownOrCanvas));
 
             // But allow for loading individual files if they exist.
             if (index.prefix.pathExists(source.folder)) return Result.success(new Set([source.folder]));
             else if (index.prefix.pathExists(source.folder + ".md"))
                 return Result.success(new Set([source.folder + ".md"]));
-
+            // allow for querying of canvas files
+            else if (index.prefix.pathExists(source.folder + ".canvas"))
+                return Result.success(new Set([source.folder + ".canvas"]));
             // For backwards-compat, return an empty result even if the folder does not exist.
             return Result.success(new Set());
         case "link":

src/data-model/canvas.ts

@@ -43,7 +43,6 @@ export class CanvasCard extends PageMetadata {
 
 export class CanvasMetadata implements Iterable<CanvasCard> {
     public path: string;
-    public originalText: string;
     public ctime: DateTime;
     public mtime: DateTime;
     public fields: any;
@@ -52,10 +51,16 @@ export class CanvasMetadata implements Iterable<CanvasCard> {
 
     public cards: CanvasCard[];
 
-    public constructor(path: string, original: string, cards: CanvasCard[], stat: FileStats) {
-        console.log("cancon", cards)
+    public static genfrom(data: any) {
+
+    }
+
+    public constructor(path: string, cards: CanvasCard[], stat: FileStats, partdata?: any) {
+        if(partdata) {
+            Object.assign(this, partdata)
+        }
+
         this.cards = cards;
-        this.originalText = original;
         this.path = path;
         this.stats = stat;
         this.ctime = cards[0].ctime
@@ -83,7 +88,7 @@ export class CanvasMetadata implements Iterable<CanvasCard> {
                 size: this.stats.size,
                 starred: index.starred.starred(this.path),
                 ext: "canvas",
-                cards: this.cards.map(a =>{
+                cards: [...this].map(a =>{
                     let realCache = cache ?? new ListSerializationCache(a.lists);
                     return {
                         frontmatter: Values.deepCopy(a.frontmatter),

src/data-model/serialized/canvas.ts

@@ -0,0 +1,34 @@
+import { Link } from "data-model/value";
+import { DateTime } from "luxon";
+import { SListItem, STask } from "./markdown";
+
+export interface SCard {
+    etags: string[];
+    tags: string[];
+    lists: SListItem[];
+    tasks: STask[];
+    [key: string]: any;
+}
+
+export interface SCanvas {
+    file: {
+        path: string;
+        folder: string;
+        name: string;
+        link: Link;
+        outlinks: Link[];
+        inlinks: Link[];
+        ctime: DateTime;
+        cday: DateTime;
+        mtime: DateTime;
+        mday: DateTime;
+        size: number;
+        ext: string;
+        starred: boolean;
+        day?: DateTime;
+        cards: SCard[]
+    };
+
+    /** Additional fields added by field data. */
+    [key: string]: any;
+}

src/query/engine.ts

@@ -10,7 +10,8 @@ import { Result } from "api/result";
 import { Field, Fields } from "expression/field";
 import { QuerySettings } from "settings";
 import { DateTime } from "luxon";
-import { SListItem } from "data-model/serialized/markdown";
+import { SListItem, SMarkdownPage, STask } from "data-model/serialized/markdown";
+import { SCanvas } from "data-model/serialized/canvas";
 
 function iden<T>(x: T): T {
     return x;
@@ -392,16 +393,28 @@ export async function executeTask(
     settings: QuerySettings
 ): Promise<Result<TaskExecution, string>> {
     let fileset = matchingSourcePaths(query.source, index, origin);
+    console.log("mfs", query.source, fileset, origin)
     if (!fileset.successful) return Result.failure(fileset.error);
 
     // Collect tasks from pages which match.
     let incomingTasks: Pagerow[] = [];
     for (let path of fileset.value) {
-        let page = index.pages.get(path);
+			let page = index.pages.get(path);
+			console.log("pa", page)
         if (!page) continue;
 
         let pageData = page.serialize(index);
-        let pageTasks = pageData.file.tasks.map(t => {
+        let intermediatePageTasks;
+
+        if((pageData as any).file.cards) {
+            intermediatePageTasks = (pageData as SCanvas).file.cards.map(a => a.tasks).flat()
+        } else {
+            intermediatePageTasks = (pageData as SMarkdownPage).file.tasks
+        }
+        console.log("ipat", pageData, intermediatePageTasks)
+        let pageTasks = intermediatePageTasks.map((t: STask) => {
+            console.debug("tttt", origin, t)
+
             const tcopy = Values.deepCopy(t);
 
             // Add page data to this copy.