@mcpher/gas-fakes 1.0.19 → 1.0.21

package/src/services/advgmail/fakeadvgmailusers.js

@@ -0,0 +1,23 @@
+import { FakeAdvResource } from '../common/fakeadvresource.js';
+import { Syncit } from '../../support/syncit.js';
+import { signatureArgs, ssError, gError } from '../../support/helpers.js';
+import { newFakeAdvGmailLabels } from './fakeadvgmaillabels.js';
+
+import { Proxies } from '../../support/proxies.js';
+import { Utils } from '../../support/utils.js';
+const { is } = Utils
+
+export const newFakeAdvGmailUsers = (...args) => Proxies.guard(new FakeAdvGmailUsers(...args))
+
+class FakeAdvGmailUsers extends FakeAdvResource {
+  constructor(mainService) {
+    super(mainService, 'gmail', Syncit.fxGmail);
+    this.gmail = mainService;
+    this.__fakeObjectType = 'Gmail.Users';
+  }
+
+  get Labels() {
+    return newFakeAdvGmailLabels(this.gmail);
+  }
+
+}

package/src/services/advgmail/gmailapis.js

@@ -0,0 +1,15 @@
+import { google } from "googleapis";
+import { Auth } from '../../support/auth.js'
+import { syncLog} from '../../support/workersync/synclogger.js'
+
+let __client = null;
+
+export const getGmailApiClient = () => {
+  const auth = Auth.getAuth()
+  if (!__client) {
+    syncLog('Creating new Gmail API client');
+    __client = google.gmail({ version: 'v1', auth });
+  }
+  return __client;
+}
+

package/src/services/advsheets/app.js

@@ -1,32 +1,12 @@
 
-/**
- * the idea here is to create a global entry for the singleton 
- * before we actually have everything we need to create it. 
- * We do this by using a proxy, intercepting calls to the 
- * initial sigleton and diverting them to a completed one
- */
-import { newFakeAdvSheets } from './fakeadvsheets.js'
-import { Proxies } from '../../support/proxies.js'
-
-
-let _app = null
 
 /**
- * adds to global space to mimic Apps Script behavior
+ * the idea here is to create an empty global entry for the singleton
+ * but only load it when it is actually used.
  */
-const name = "Sheets"
-if (typeof globalThis[name] === typeof undefined) {
-
-  const getApp = () => {
-    // if it hasne been intialized yet then do that
-    if (!_app) {
-      console.log('...activating proxy for', name)
-      _app = newFakeAdvSheets()
-    }
-    // this is the actual driveApp we'll return from the proxy
-    return _app
-  }
 
-  Proxies.registerProxy(name, getApp)
+import { newFakeAdvSheets as maker} from './fakeadvsheets.js'
+import { lazyLoaderApp } from '../common/lazyloader.js'
 
-}
+let _app = null;
+_app = lazyLoaderApp(_app, 'Sheets', maker)

package/src/services/advslides/app.js

@@ -1,32 +1,10 @@
 
 /**
- * the idea here is to create a global entry for the singleton 
- * before we actually have everything we need to create it. 
- * We do this by using a proxy, intercepting calls to the 
- * initial sigleton and diverting them to a completed one
+ * the idea here is to create an empty global entry for the singleton
+ * but only load it when it is actually used.
  */
-import { newFakeAdvSlides } from './fakeadvslides.js'
-import { Proxies } from '../../support/proxies.js'
+import { newFakeAdvSlides as maker } from './fakeadvslides.js'
+import { lazyLoaderApp } from '../common/lazyloader.js'
 
-// This will eventually hold a proxy for slidesapp
-let _app = null
-
-/**
- * adds to global space to mimic Apps Script behavior
- */
-const name = "Slides"
-if (typeof globalThis[name] === typeof undefined) {
-
-  const getApp = () => {
-    // if it hasne been intialized yet then do that
-    if (!_app) {
-      console.log('...activating proxy for', name)
-      _app = newFakeAdvSlides()
-    }
-    // this is the actual driveApp we'll return from the proxy
-    return _app
-  }
-
-  Proxies.registerProxy(name, getApp)
-
-}
+let _app = null;
+_app = lazyLoaderApp(_app, 'Slides', maker)

package/src/services/common/lazyloader.js

@@ -0,0 +1,22 @@
+import { Proxies } from '../../support/proxies.js';
+
+export const lazyLoaderApp = (app, name, maker) => {
+
+    if (typeof globalThis[name] === typeof undefined) {
+
+        const getApp = () => {
+   
+            // if it hasne been intialized yet then do that
+            if (!app) {
+                //console.log ('...loading', name)
+                app = maker()
+            }
+            // this is the actual driveApp we'll return from the proxy
+            return app
+        }
+        //console.log ('...registering', name)
+        Proxies.registerProxy(name, getApp)
+
+    }
+    return app
+}

package/src/services/documentapp/app.js

@@ -1,47 +1,13 @@
+
+
 /**
- * the idea here is to create a global entry for the singleton
- * before we actually have everything we need to create it.
- * We do this by using a proxy, intercepting calls to the
- * initial sigleton and diverting them to a completed one.
- * We also need to make sure all element types are registered.
+ * the idea here is to create an empty global entry for the singleton
+ * but only load it when it is actually used.
  */
-import { newFakeDocumentApp } from './fakedocumentapp.js';
-import { Proxies } from '../../support/proxies.js';
+
+import { lazyLoaderApp } from '../common/lazyloader.js'
+import { newFakeDocumentApp as maker } from './fakedocumentapp.js';
 import './elements.js'; // This ensures all element types register themselves before DocumentApp is used.
 
 let _app = null;
-
-const name = 'DocumentApp';
-const serviceName = 'DocumentApp';
-
-if (typeof globalThis[name] === typeof undefined) {
-  // By importing this, we ensure all element types register themselves.
-  const getApp = () => {
-    if (!_app) {
-      const realApp = newFakeDocumentApp();
-
-      _app = new Proxy(realApp, {
-        get(target, prop, receiver) {
-          if (prop === 'toString') {
-            return () => name;
-          }
-
-          const serviceBehavior = ScriptApp.__behavior.sandboxService[serviceName];
-
-          if (!serviceBehavior.enabled) {
-            throw new Error(`${name} service is disabled by sandbox settings.`);
-          }
-
-          const allowedMethods = serviceBehavior.methods;
-          if (allowedMethods && typeof target[prop] === 'function' && !allowedMethods.includes(prop)) {
-            throw new Error(`Method ${name}.${prop} is not allowed by sandbox settings.`);
-          }
-
-          return Reflect.get(...arguments);
-        },
-      });
-    }
-    return _app;
-  };
-  Proxies.registerProxy(name, getApp);
-}
+_app = lazyLoaderApp(_app, 'DocumentApp', maker)

package/src/services/documentapp/appenderhelpers.js

@@ -1,6 +1,6 @@
 import { Utils } from "../../support/utils.js";
 import { ElementType } from '../enums/docsenums.js';
-const { is, isBlob } = Utils
+const { is, isBlob , stringCircular, lobify} = Utils
 import { getElementFactory } from './elementRegistry.js'
 import { signatureArgs, notYetImplemented } from '../../support/helpers.js';
 import { findItem } from './elementhelpers.js';
@@ -121,7 +121,7 @@ const calculateInsertionPointsAndInitialRequests = (self, childIndex, isAppend,
     if (isParaInsert) {
       // Inserting into an existing paragraph. No newlines needed.
       if (childIndex < 0 || childIndex > children.length) {
-        throw new Error(`Child index (${childIndex}) must be between 0 and the number of child elements (${children.length}).`);
+        throw new Error(`Child index (${childIndex}) must be less than or equal to the number of child elements (${children.length}).`);
       }
       if (children.length === 0 || childIndex === children.length) {
         // Inserting into an empty paragraph or at the end.
@@ -136,23 +136,29 @@ const calculateInsertionPointsAndInitialRequests = (self, childIndex, isAppend,
       childStartIndex = insertIndex; // The new child will start where we insert it.
     } else {
       // It's an insert operation, creating a new element in a Body/Header/etc.
-      if (childIndex < 0 || childIndex >= children.length) {
+      if (childIndex < 0 || childIndex > children.length) {
         throw new Error(`Child index (${childIndex}) must be less than or equal to the number of child elements (${children.length}).`);
       }
-      const targetChildTwig = children[childIndex];
-      const targetChildItem = elementMap.get(targetChildTwig.name);
+      // Handle the case where we are inserting at the end (which is like an append).
+      if (childIndex === children.length) {
+        const lastChildTwig = children.length > 0 ? children[children.length - 1] : null;
+        const lastChildItem = lastChildTwig ? elementMap.get(lastChildTwig.name) : item;
+        insertIndex = lastChildItem.endIndex - 1;
+        newElementStartIndex = lastChildItem.endIndex;
+        leading = '\n';
+      } else {
+        const targetChildTwig = children[childIndex];
+        const targetChildItem = elementMap.get(targetChildTwig.name);
 
-      if (targetChildItem.__type === "TABLE") {
-        insertIndex = targetChildItem.startIndex - 1; // Insert before the table.
-        if (childIndex < 1) {
-          throw new Error(`Cannot insert before the first child element table (${targetChildItem.name})`);
+        if (targetChildItem.__type === "TABLE") {
+          insertIndex = targetChildItem.startIndex - 1; // Insert before the table.
+          leading = '\n';
+          newElementStartIndex = insertIndex + 1;
+        } else {
+          insertIndex = targetChildItem.startIndex;
+          trailing = '\n';
+          newElementStartIndex = insertIndex;
         }
-        leading = '\n'
-        newElementStartIndex = insertIndex + 1;
-      } else {
-        insertIndex = targetChildItem.startIndex
-        trailing = '\n'
-        newElementStartIndex = insertIndex;
       }
       childStartIndex = null; // Child start index is unknown, must be found within container.
     }
@@ -301,14 +307,6 @@ const elementInserter = (self, elementOrText, childIndex, options) => {
     }
   }
 
-  // After the refresh, the 'self' object is stale. We need to find its new representation
-  // in the updated element map and update its internal name. This "revives" the object
-  // for subsequent method calls in the user's script.
-  const newSelfItem = findItem(shadow.elementMap, selfType, selfStartIndex, segmentId);
-  if (newSelfItem && newSelfItem.__name !== selfName) {
-    self.__name = newSelfItem.__name;
-  }
-
   // 6. Handle table content population if necessary. This is a two-phase update
   // because we need the table to exist before we can get the indices to populate its cells.
   if (options.elementType === ElementType.TABLE) {

package/src/services/documentapp/elementhelpers.js

@@ -285,5 +285,4 @@ export const updateParagraphStyle = (element, paragraphStyle, fields) => {
   Docs.Documents.batchUpdate({ requests }, shadow.getId());
   shadow.refresh();
   return element;
-  
 };

package/src/services/documentapp/elementoptions.js

@@ -381,11 +381,13 @@ export const imageOptions = {
   elementType: ElementType.INLINE_IMAGE,
   insertMethodSignature: 'DocumentApp.Body.insertImage',
   canAcceptText: false,
-  getMainRequest: ({ content: image, location, isAppend, self, leading, trailing }) => {
+  // This internal helper is extracted so it can be used by Paragraph.appendInlineImage
+  // without invoking the complex request-building logic of getMainRequest.
+  __getImageUriAndSize: (image) => {
     const isDetachedImage = is.object(image) && is.function(image.getType) && image.getType() === ElementType.INLINE_IMAGE;
     const isBlobSource = isBlob(image);
 
-    let uri, size, fileId;
+    let uri, size, fileId, cleanup = null;
 
     if (isDetachedImage) {
       if (!image.__isDetached) throw new Error('Element must be detached.');
@@ -446,13 +448,14 @@ export const imageOptions = {
         }
         uri = fileWithLink.webContentLink;
 
-
-        // We can get the byte size, but not the height/width for a blob.
-        // The API seems to require an objectSize, so we'll provide a default.
-        // This is the desired size in the document, not the intrinsic image size.
         size = {
-          height: { magnitude: 100, unit: 'PT' },
-          width: { magnitude: 100, unit: 'PT' },
+          height: { magnitude: image.getHeight ? image.getHeight() : 100, unit: 'PT' },
+          width: { magnitude: image.getWidth ? image.getWidth() : 100, unit: 'PT' },
+        };
+
+        cleanup = () => {
+          try { Drive.Files.update({ trashed: true }, fileId); }
+          catch (e) { console.warn(`Failed to cleanup temporary image file ${fileId}:`, e.message); }
         };
       } catch (e) {
         // if something fails during setup, trash the file immediately
@@ -466,9 +469,15 @@ export const imageOptions = {
     } else {
       throw new Error('Only inserting a copied (detached) InlineImage or a Blob is supported at this time.');
     }
+    return { uri, size, cleanup };
+  },
+  getMainRequest: ({ content: image, location, isAppend, self, leading, trailing }) => {
+    const { uri, size, cleanup } = imageOptions.__getImageUriAndSize(image);
+
     if (!uri) {
       throw new Error('Could not determine image URI for insertion.');
     }
+
     const imageRequest = {
       insertInlineImage: {
         uri,
@@ -480,32 +489,13 @@ export const imageOptions = {
       imageRequest.insertInlineImage.objectSize = size;
     }
 
-    let finalRequests;
-    if (leading) { // Append case
-      const textRequest = { insertText: { text: leading, location } }; // leading is '\n'
-      // The image needs to be inserted into the new paragraph created by the leading newline.
-      // The new paragraph will start at location.index + 1.
-      const imageLocation = { ...location, index: location.index + 1 };
-      const imageRequestWithCorrectedLocation = { ...imageRequest, insertInlineImage: { ...imageRequest.insertInlineImage, location: imageLocation } };
-      finalRequests = [textRequest, imageRequestWithCorrectedLocation];
-    } else if (trailing) { // Insert case
-      const textRequest = { insertText: { text: trailing, location } };
-      // Insert a newline, then the image at the same location. The API inserts the image after the newline.
-      finalRequests = [textRequest, imageRequest];
-    } else {
-      // This case is for inserting into an existing paragraph (e.g., Paragraph.appendImage).
-      finalRequests = [imageRequest];
-    }
+    const textRequest = (leading || trailing) ? { insertText: { text: leading || trailing, location } } : null;
+    const imageLocation = (leading) ? { ...location, index: location.index + 1 } : location;
+    const imageRequestWithCorrectedLocation = { ...imageRequest, insertInlineImage: { ...imageRequest.insertInlineImage, location: imageLocation } };
 
-    if (isBlobSource) {
-      const cleanup = () => {
-        try { Drive.Files.update({ trashed: true }, fileId); }
-        catch (e) { console.warn(`Failed to cleanup temporary image file ${fileId}:`, e.message); }
-      };
-      return { requests: finalRequests, cleanup };
-    }
+    const finalRequests = textRequest ? [textRequest, imageRequestWithCorrectedLocation] : [imageRequestWithCorrectedLocation];
 
-    return finalRequests;
+    return { requests: finalRequests, cleanup };
   },
   getStyleRequests: null, // Styling is part of the image object itself.
   findType: 'PARAGRAPH', // We are creating a paragraph to hold the image.

package/src/services/documentapp/fakeelement.js

@@ -7,6 +7,7 @@ import { Utils } from '../../support/utils.js';
 const { is } = Utils;
 import { ElementType } from '../enums/docsenums.js';
 import { getElementFactory } from './elementRegistry.js';
+import { findItem } from './elementhelpers.js';
 
 /**
  * @typedef {import('./shadow.js').ShadowStructure} ShadowStructure
@@ -71,7 +72,11 @@ export class FakeElement {
           throw new Error(`Invalid arguments for attached FakeElement: ${nameOrItem}. Name must start with '${shadowPrefix}'.`);
         }
         this.__isDetached = false;
-      this.__shadowDocument = shadowDocument;
+        this.__shadowDocument = shadowDocument;
+        // Cache the element's initial position. This is the key to "reviving" the element.
+        const initialItem = this.__getElementMapItem(nameOrItem);
+        this.__initialStartIndex = initialItem.startIndex;
+        this.__initialSegmentId = initialItem.__segmentId;
         this.__name = nameOrItem;
         this.__detachedItem = null;
       } else if (is.object(nameOrItem)) { // Detached
@@ -105,7 +110,18 @@ export class FakeElement {
     if (this.__isDetached) {
       return this.__detachedItem;
     }
-    return this.__getElementMapItem(this.__name);
+
+    // 1. Try the last known name. This is fast if nothing has changed.
+    const lastKnownItem = this.__getElementMapItem(this.__name, true); // noThrow = true
+    if (lastKnownItem) {
+      return lastKnownItem;
+    }
+
+    // 2. If the last name was stale, find the element by its initial position.
+    const revivedItem = findItem(this.__shadowDocument.elementMap, this.getType().toString(), this.__initialStartIndex, this.__initialSegmentId);
+    // 3. Update the internal name so the next lookup is fast again.
+    this.__name = revivedItem.__name;
+    return revivedItem;
   }
 
   /**
@@ -114,9 +130,10 @@ export class FakeElement {
    * @returns {object} The element map item.
    * @private
    */
-  __getElementMapItem(name) {
+  __getElementMapItem(name, noThrow = false) {
     const item = this.__shadowDocument.getElement(name);
     if (!item) {
+      if (noThrow) return null;
       throw new Error(`element with name ${name} not found`);
     }
     return item;