@malloy-publisher/sdk 0.0.80 → 0.0.82

package/src/components/MutableNotebook/MutableNotebookList.tsx

@@ -1,69 +0,0 @@
-import { Box, Divider, List, ListItem, ListItemText } from "@mui/material";
-import React from "react";
-import { useNotebookStorage } from "./NotebookStorageProvider";
-
-interface MutableNotebookListProps {
-   onNotebookClick: (notebook: string, event: React.MouseEvent) => void;
-}
-
-export function MutableNotebookList({
-   onNotebookClick,
-}: MutableNotebookListProps) {
-   const { notebookStorage, userContext } = useNotebookStorage();
-   const [notebooks, setNotebooks] = React.useState<string[]>([]);
-
-   React.useEffect(() => {
-      if (notebookStorage && userContext) {
-         setNotebooks(notebookStorage.listNotebooks(userContext));
-      }
-   }, [notebookStorage, userContext]);
-
-   return (
-      <>
-         <Divider />
-         <Box
-            sx={{
-               maxHeight: "300px",
-               overflow: "auto",
-               "&::-webkit-scrollbar": {
-                  width: "8px",
-               },
-               "&::-webkit-scrollbar-track": {
-                  background: "transparent",
-               },
-               "&::-webkit-scrollbar-thumb": {
-                  background: "rgba(0,0,0,0.2)",
-                  borderRadius: "4px",
-               },
-            }}
-         >
-            <List dense>
-               {notebooks.length === 0 && (
-                  <ListItem>
-                     <ListItemText
-                        primary="No notebooks found."
-                        sx={{ textAlign: "center" }}
-                     />
-                  </ListItem>
-               )}
-               {notebooks.map((notebook) => (
-                  <ListItem
-                     key={notebook}
-                     onClick={(event: React.MouseEvent) =>
-                        onNotebookClick(notebook, event)
-                     }
-                     sx={{
-                        cursor: "pointer",
-                        "&:hover": {
-                           backgroundColor: "action.hover",
-                        },
-                     }}
-                  >
-                     <ListItemText primary={notebook} />
-                  </ListItem>
-               ))}
-            </List>
-         </Box>
-      </>
-   );
-}

package/src/components/MutableNotebook/NotebookStorage.ts

@@ -1,27 +0,0 @@
-export interface UserContext {
-   // UserContext holds the project & package associated with
-   // the notebook. PublisherStorage interfaces will
-   // implement this and add data representing configuration,
-   // user permissions, and access tokens.
-   project: string;
-   package: string;
-}
-
-export interface NotebookStorage {
-   // Lists all available notebooks for the context.
-   // Notebooks names are like S3 paths- / denote hierarchical
-   // folders, but otherwise folders are not "real" objects
-   listNotebooks(context: UserContext): string[];
-
-   // Returns the notebook at the specific path, throws an exception if no such notebook exists (or cannot be accessed)
-   getNotebook(context: UserContext, path: string): string;
-
-   // Deletes the notebook at the specified path, or throws an
-   // Exception on failure
-   deleteNotebook(context: UserContext, path: string): void;
-
-   saveNotebook(context: UserContext, path: string, notebook: string): void;
-
-   // Moves notebook from the "from" path to the "to" path
-   moveNotebook(context: UserContext, from: string, to: string): void;
-}

package/src/components/MutableNotebook/NotebookStorageProvider.tsx

@@ -1,43 +0,0 @@
-import React, { createContext, useContext, useMemo } from "react";
-import type { NotebookStorage, UserContext } from "./NotebookStorage";
-
-interface NotebookStorageProviderProps {
-   children: React.ReactNode;
-   userContext: UserContext;
-   notebookStorage: NotebookStorage;
-}
-
-interface NotebookStorageContextValue {
-   notebookStorage: NotebookStorage;
-   userContext: UserContext;
-}
-
-const NotebookStorageContext = createContext<
-   NotebookStorageContextValue | undefined
->(undefined);
-
-export default function NotebookStorageProvider({
-   children,
-   userContext,
-   notebookStorage,
-}: NotebookStorageProviderProps) {
-   const value = useMemo(
-      () => ({ notebookStorage, userContext }),
-      [notebookStorage, userContext],
-   );
-   return (
-      <NotebookStorageContext.Provider value={value}>
-         {children}
-      </NotebookStorageContext.Provider>
-   );
-}
-
-export function useNotebookStorage() {
-   const context = useContext(NotebookStorageContext);
-   if (!context) {
-      throw new Error(
-         "useNotebookStorage must be used within a NotebookStorageProvider",
-      );
-   }
-   return context;
-}

package/src/components/MutableNotebook/index.ts

@@ -1,8 +0,0 @@
-export { BrowserNotebookStorage } from "./BrowserNotebookStorage";
-export { default as MutableNotebook } from "./MutableNotebook";
-export type { NotebookStorage, UserContext } from "./NotebookStorage";
-export { MutableNotebookList } from "./MutableNotebookList";
-export {
-   default as NotebookStorageProvider,
-   useNotebookStorage,
-} from "./NotebookStorageProvider";

package/src/components/NotebookManager.ts

@@ -1,225 +0,0 @@
-import type {
-   NotebookStorage,
-   UserContext,
-} from "./MutableNotebook/NotebookStorage";
-
-/**
- * Interface representing the data structure of a Mutable Notebook
- * @interface NotebookData
- * @property {string[]} models - Array of model paths used in the notebook
- * @property {NotebookCellValue[]} cells - Array of cells in the notebook
- * @property {string} notebookPath - Path to the notebook file (relative to project/package)
- */
-export interface NotebookData {
-   models: string[];
-   cells: NotebookCellValue[];
-   notebookPath: string;
-}
-
-/**
- * Interface representing a cell in the notebook
- * @interface NotebookCellValue
- * @property {boolean} isMarkdown - Whether the cell is a markdown cell
- * @property {string} [value] - The content of the cell
- * @property {string} [result] - The result of executing the cell
- * @property {string} [modelPath] - modelPath associated with the query in the cell
- * @property {string} [sourceName] - Name of the source associated with the cell
- * @property {string} [queryInfo] - Information about the query in the cell
- */
-export interface NotebookCellValue {
-   isMarkdown: boolean;
-   value?: string;
-   result?: string;
-   modelPath?: string;
-   sourceName?: string;
-   queryInfo?: string;
-}
-
-/**
- * Class for managing notebook operations
- * @class NotebookManager
- */
-export class NotebookManager {
-   private isSaved: boolean;
-   private notebookStorage: NotebookStorage;
-   private userContext: UserContext;
-
-   /**
-    * Creates a new NotebookManager instance
-    * @param {NotebookStorage} notebookStorage - Storage implementation
-    * @param {UserContext} userContext - User context for storage
-    * @param {NotebookData} notebookData - Initial notebook data
-    */
-   constructor(
-      notebookStorage: NotebookStorage,
-      userContext: UserContext,
-      private notebookData: NotebookData,
-   ) {
-      this.notebookStorage = notebookStorage;
-      this.userContext = userContext;
-      if (this.notebookData) {
-         this.isSaved = true;
-      } else {
-         this.notebookData = {
-            models: [],
-            cells: [],
-            notebookPath: undefined,
-         };
-         this.isSaved = false;
-      }
-   }
-
-   /**
-    * Gets the current notebook data
-    * @returns {NotebookData} The current notebook data
-    */
-   getNotebookData(): NotebookData {
-      return this.notebookData;
-   }
-
-   /**
-    * Gets the current notebook path
-    * @returns {string} The path to the notebook
-    */
-   getNotebookPath(): string {
-      return this.notebookData.notebookPath;
-   }
-
-   /**
-    * Renames the notebook and updates storage
-    * @param {string} notebookPath - New path for the notebook
-    * @returns {NotebookManager} The updated NotebookManager instance
-    */
-   renameNotebook(notebookPath: string): NotebookManager {
-      if (this.notebookData.notebookPath !== notebookPath) {
-         try {
-            this.notebookStorage.deleteNotebook(
-               this.userContext,
-               this.notebookData.notebookPath,
-            );
-         } catch {
-            // ignore if not found
-         }
-      }
-      this.notebookData.notebookPath = notebookPath;
-      this.isSaved = false;
-      this.saveNotebook();
-      return this;
-   }
-
-   getCells(): NotebookCellValue[] {
-      return this.notebookData.cells;
-   }
-   deleteCell(index: number): NotebookManager {
-      this.notebookData.cells = [
-         ...this.notebookData.cells.slice(0, index),
-         ...this.notebookData.cells.slice(index + 1),
-      ];
-      this.isSaved = false;
-      return this;
-   }
-   insertCell(index: number, cell: NotebookCellValue): NotebookManager {
-      this.notebookData.cells = [
-         ...this.notebookData.cells.slice(0, index),
-         cell,
-         ...this.notebookData.cells.slice(index),
-      ];
-      this.isSaved = false;
-      return this;
-   }
-   setCell(index: number, cell: NotebookCellValue): NotebookManager {
-      this.notebookData.cells[index] = cell;
-      this.isSaved = false;
-      return this;
-   }
-   setModels(models: string[]): NotebookManager {
-      this.notebookData.models = models;
-      this.isSaved = false;
-      return this;
-   }
-   getModels(): string[] {
-      return this.notebookData.models;
-   }
-
-   updateNotebookData(notebookData: NotebookData): NotebookManager {
-      this.notebookData = notebookData;
-      this.isSaved = false;
-      return this;
-   }
-
-   saveNotebook(): NotebookManager {
-      if (!this.isSaved) {
-         if (!this.notebookData.notebookPath) {
-            throw new Error("Notebook path is not set");
-         }
-         this.notebookStorage.saveNotebook(
-            this.userContext,
-            this.notebookData.notebookPath,
-            JSON.stringify(this.notebookData),
-         );
-         this.isSaved = true;
-      }
-      return new NotebookManager(
-         this.notebookStorage,
-         this.userContext,
-         this.notebookData,
-      );
-   }
-
-   /**
-    * Converts the notebook data to a Malloy notebook string.
-    * @returns {string} The Malloy notebook string
-    */
-   toMalloyNotebook(): string {
-      return this.notebookData.cells
-         .map((cell) => {
-            if (cell.isMarkdown) {
-               return ">>>markdown\n" + cell.value;
-            } else {
-               return (
-                  ">>>malloy\n" +
-                  `import {${cell.sourceName}}" from '${cell.modelPath}'"\n` +
-                  cell.value +
-                  "\n"
-               );
-            }
-         })
-         .join("\n");
-   }
-
-   static newNotebook(
-      notebookStorage: NotebookStorage,
-      userContext: UserContext,
-   ): NotebookManager {
-      return new NotebookManager(notebookStorage, userContext, undefined);
-   }
-
-   /**
-    * Creates a new notebook manager by loading from local storage.
-    * Returns an empty instance if the notebook is not found.
-    * @param notebookStorage - The storage implementation
-    * @param userContext - The user context for storage
-    * @param notebookPath - The path to the notebook file (relative to project/package)
-    */
-   static loadNotebook(
-      notebookStorage: NotebookStorage,
-      userContext: UserContext,
-      notebookPath: string,
-   ): NotebookManager {
-      let notebookData: NotebookData | undefined = undefined;
-      try {
-         const saved = notebookStorage.getNotebook(userContext, notebookPath);
-         if (saved) {
-            notebookData = JSON.parse(saved);
-         }
-      } catch {
-         // Not found, create a new notebook
-         notebookData = {
-            models: [],
-            cells: [],
-            notebookPath: notebookPath,
-         };
-      }
-      return new NotebookManager(notebookStorage, userContext, notebookData);
-   }
-}