@zxncij2390/monorepo3 3.18.0

package/debug/spfx/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "spfx-1-16-1",
+  "version": "0.0.1",
+  "private": true,
+  "engines": {
+    "node": ">=16.13.0 <17.0.0"
+  },
+  "main": "lib/index.js",
+  "scripts": {
+    "build": "gulp bundle",
+    "clean": "gulp clean",
+    "test": "gulp test"
+  },
+  "dependencies": {
+    "@microsoft/sp-core-library": "1.16.1",
+    "@microsoft/sp-lodash-subset": "1.16.1",
+    "@microsoft/sp-office-ui-fabric-core": "1.16.1",
+    "@microsoft/sp-property-pane": "1.16.1",
+    "@microsoft/sp-webpart-base": "1.16.1",
+    "@pnp/core": "^3.13.0",
+    "@pnp/graph": "^3.13.0",
+    "@pnp/logging": "^3.13.0",
+    "@pnp/sp": "^3.13.0",
+    "tslib": "2.3.1"
+  },
+  "devDependencies": {
+    "@microsoft/eslint-config-spfx": "1.16.1",
+    "@microsoft/eslint-plugin-spfx": "1.16.1",
+    "@microsoft/rush-stack-compiler-4.5": "0.2.2",
+    "@microsoft/sp-build-web": "1.16.1",
+    "@microsoft/sp-module-interfaces": "1.16.1",
+    "@rushstack/eslint-config": "2.5.1",
+    "@types/webpack-env": "~1.15.2",
+    "ajv": "^6.12.5",
+    "gulp": "4.0.2",
+    "typescript": "4.5.5"
+  }
+}

package/debug/spfx/pnpjs-local-debug-start.js

@@ -0,0 +1,19 @@
+const child_process = require("child_process");
+const path = require("path");
+
+// give ourselves a single reference to the projectRoot
+const projectRoot = path.resolve("./");
+
+const isWin = process.platform === "win32";
+
+// start up tsc on the serve tsconfig, which will execute in watch mode
+child_process.spawn(isWin ? "npx.cmd" : "npx", ["tsc", "-p", "./packages/tsconfig-watch.json"], {
+    cwd: projectRoot,
+    stdio: "inherit",
+});
+
+// run our server
+child_process.spawn(isWin ? "npx.cmd" : "npx", ["gulp", "serve", "--nobrowser"], {
+    cwd: __dirname,
+    stdio: "inherit",
+});

package/docs/_theme/main.html

@@ -0,0 +1,5 @@
+{% extends "base.html" %}
+
+{% block analytics %}
+    <img src="https://m365-visitor-stats.azurewebsites.net/@pnp/pnpjs/ghpages{{ page.abs_url }}" alt="spacer" width="1" height="1" />
+{% endblock %}

package/docs/azidjsclient/index.md

@@ -0,0 +1,36 @@
+# @pnp/azidjsclient
+
+This library provides a thin wrapper around the [@azure/identity](https://github.com/Azure/azure-sdk-for-js) library to make it easy to integrate Azure Identity authentication in your solution.
+
+You will first need to install the package:
+
+`npm install @pnp/azidjsclient --save`
+
+The following example shows how to configure the SPFI or GraphFI object using this behavior.
+
+```TypeScript
+import { DefaultAzureCredential } from "@azure/identity";
+import { spfi } from "@pnp/sp";
+import { graphfi } from "@pnp/sp";
+import { SPDefault, GraphDefault } from "@pnp/nodejs";
+import { AzureIdentity } from "@pnp/azidjsclient";
+import "@pnp/sp/webs";
+import "@pnp/graph/me";
+
+const credential = new DefaultAzureCredential();
+
+const sp = spfi("https://tenant.sharepoint.com/sites/dev").using(
+    SPDefault(),
+    AzureIdentity(credential, [`https://${tenant}.sharepoint.com/.default`], null)
+);
+
+const graph = graphfi().using(
+    GraphDefault(),
+    AzureIdentity(credential, ["https://graph.microsoft.com/.default"], null)
+);
+
+const webData = await sp.web();
+const meData = await graph.me();
+```
+
+Please see more scenarios in the [authentication article](../concepts/authentication.md).

package/docs/concepts/adv-clientside-pages.md

@@ -0,0 +1,169 @@
+# Client-Side Pages
+
+The client-side pages API included in this library is an implementation that was reverse engineered from the first-party API's and is unsupported by Microsoft. Given how flexible pages are we've done our best to give you the endpoints that will provide the functionality you need but that said, implementing these APIs is one of the more complicated tasks you can do.
+
+It's especially important to understand the product team is constantly changing the features of pages and often that will also end up changing how the APIs that we've leveraged behave and because they are not offical third-party APIs this can cause our implementation to break.  In order to fix those breaks we need to go back to the beginning and re-validate how the endpoints work searching for what has changed and then implementing those changes in our code. This is by no means simple. If you are reporting an issue with the pages API be aware that it may take significant time for us to unearth what is happening and fix it. Any research that you can provide when sharing your issue will go a long way in expediating that process, or better yet, if you can track it down and submit a PR with a fix we would be most greatful.
+
+## Tricks to help you figure out how to add first-party web parts to your page
+
+This section is to offer you methods to be able to reverse engineer some of the first party web parts to help figure out how to add them to the page using the `addControl` method.
+
+Your first step needs to be creating a test page that you can inspect.
+
+1. Create a new Site Page.
+1. Open the browser console, and navigate to the network tab
+1. Filter the network tab for `Fetch/XHR` and then type `SavePage` to filter for the specific network calls.
+1. Add and configure the web part you want to reverse engineer and then save the page as draft. The network tab will now show a `SavePageAsDraft` call and you can then look at the `Payload` of that call
+    ![Client-Side Pages Network Tab Image](../img/csp_networktab.png)
+1. You then want to specifically look at the `CanvasContent1` property and copy that value. You can then paste it into a temporary file with the .json extension in your code editor so you can inspect the payload. The value is an array of objects, and each object (except the last) is the definition of the web part.
+
+Below is an example (as of the last change date of this document) of what the QuickLinks web part looks like. One key takeaway from this file is the `webPartId` property which can be used when filtering for the right web part definition after getting a collection from `sp.web.getClientsideWebParts();`.
+>Note that it could change at any time so please do not rely on this data, please use it as an example only.
+
+```JSON
+{
+    "position": {
+        "layoutIndex": 1,
+        "zoneIndex": 1,
+        "sectionIndex": 1,
+        "sectionFactor": 12,
+        "controlIndex": 1
+    },
+    "controlType": 3,
+    "id": "00000000-58fd-448c-9e40-6691ce30e3e4",
+    "webPartId": "c70391ea-0b10-4ee9-b2b4-006d3fcad0cd",
+    "addedFromPersistedData": true,
+    "reservedHeight": 141,
+    "reservedWidth": 909,
+    "webPartData": {
+        "id": "c70391ea-0b10-4ee9-b2b4-006d3fcad0cd",
+        "instanceId": "00000000-58fd-448c-9e40-6691ce30e3e4",
+        "title": "Quick links",
+        "description": "Show a collection of links to content such as documents, images, videos, and more in a variety of layouts with options for icons, images, and audience targeting.",
+        "audiences": [],
+        "serverProcessedContent": {
+            "htmlStrings": {},
+            "searchablePlainTexts": {
+                "items[0].title": "PnPjs Title"
+            },
+            "imageSources": {},
+            "links": {
+                "baseUrl": "https://contoso.sharepoint.com/sites/PnPJS",
+                "items[0].sourceItem.url": "/sites/PnPJS/SitePages/pnpjsTestV2.aspx"
+            },
+            "componentDependencies": {
+                "layoutComponentId": "706e33c8-af37-4e7b-9d22-6e5694d92a6f"
+            }
+        },
+        "dataVersion": "2.2",
+        "properties": {
+            "items": [
+                {
+                    "sourceItem": {
+                        "guids": {
+                            "siteId": "00000000-4657-40d2-843d-3d6c72e647ff",
+                            "webId": "00000000-e714-4de6-88db-b0ac40d17850",
+                            "listId": "{00000000-8ED8-4E43-82BD-56794D9AB290}",
+                            "uniqueId": "00000000-6779-4979-adad-c120a39fe311"
+                        },
+                        "itemType": 0,
+                        "fileExtension": ".ASPX",
+                        "progId": null
+                    },
+                    "thumbnailType": 2,
+                    "id": 1,
+                    "description": "",
+                    "fabricReactIcon": {
+                        "iconName": "heartfill"
+                    },
+                    "altText": "",
+                    "rawPreviewImageMinCanvasWidth": 32767
+                }
+            ],
+            "isMigrated": true,
+            "layoutId": "CompactCard",
+            "shouldShowThumbnail": true,
+            "imageWidth": 100,
+            "buttonLayoutOptions": {
+                "showDescription": false,
+                "buttonTreatment": 2,
+                "iconPositionType": 2,
+                "textAlignmentVertical": 2,
+                "textAlignmentHorizontal": 2,
+                "linesOfText": 2
+            },
+            "listLayoutOptions": {
+                "showDescription": false,
+                "showIcon": true
+            },
+            "waffleLayoutOptions": {
+                "iconSize": 1,
+                "onlyShowThumbnail": false
+            },
+            "hideWebPartWhenEmpty": true,
+            "dataProviderId": "QuickLinks",
+            "webId": "00000000-e714-4de6-88db-b0ac40d17850",
+            "siteId": "00000000-4657-40d2-843d-3d6c72e647ff"
+        }
+    }
+}
+```
+
+At this point the only aspect of the above JSON payload you're going to be paying attention to is the `webPartData`. We have exposed `title`, `description`, and `dataVersion` as default properties of the `ClientsideWebpart` class. In addition we provide a `getProperties`, `setProperties`, `getServerProcessedContent`, `setServerProcessedContent` methods. The difference in this case in these set base methods is that it will merge the object you pass into those methods with the values already on the object.
+
+The code below gives a incomplete but demonstrative example of how you would extend the ClientsideWebpart class to provide an interface to build a custom class for the QuickLinks web part illustrated in our JSON payload above. This code assumes you have already added the control to a section. For more information about that step see the documentation for [Add Controls](../sp/clientside-pages.md#Add_Controls)
+
+```TypeScript
+import { sp } from "@pnp/sp";
+import "@pnp/sp/webs";
+import { ClientsideWebpart } from "@pnp/sp/clientside-pages";
+
+//Define interface based on JSON object above
+interface IQLItem {
+    sourceItem: {
+        guids: {
+            siteId: string;
+            webId:  string;
+            listId:  string;
+            uniqueId:  string;
+        },
+        itemType: number;
+        fileExtension: string;
+        progId: string;
+    }
+    thumbnailType: number;
+    id: number;
+    description: string;
+    fabricReactIcon: { iconName: string; };
+    altText: string;
+    rawPreviewImageMinCanvasWidth: number;
+}
+
+// we create a class to wrap our functionality in a reusable way
+class QuickLinksWebpart extends ClientsideWebpart {
+
+  constructor(control: ClientsideWebpart) {
+    super((<any>control).json);
+  }
+
+  // add property getter/setter for what we need, in this case items array within properties
+  public get items(): IQLItem[] {
+    return this.json.webPartData?.properties?.items || [];
+  }
+
+  public set items(value: IQLItem[]) {
+    this.json.webPartData.properties?.items = value;
+  }
+}
+
+// now we load our page
+const page = await sp.web.loadClientsidePage("/sites/PnPJS/SitePages/QuickLinks-Web-Part-Test.aspx");
+
+// get our part and pass it to the constructor of our wrapper class.
+const part = new QuickLinksWebpart(page.sections[0].columns[0].getControl(0));
+
+//Need to set all the properties
+part.items = [{IQLItem_properties}];
+
+await page.save();
+```

package/docs/concepts/auth-browser.md

@@ -0,0 +1,42 @@
+# Authentication in a custom browser based application
+
+We support MSAL for both browser and nodejs by providing a thin wrapper around the official libraries. We won't document the fully possible MSAL configuration, but any parameters supplied are passed through to the underlying implementation. To use the browser MSAL package you'll need to install the @pnp/msaljsclient package which is deployed as a standalone due to the large MSAL dependency.
+
+`npm install @pnp/msaljsclient --save`
+
+At this time we're using version 1.x of the `msal` library which uses Implicit Flow. For more informaiton on the msal library please see the [AzureAD/microsoft-authentication-library-for-js](https://github.com/AzureAD/microsoft-authentication-library-for-js#readme).
+
+Each of the following samples reference a MSAL configuration that utilizes an Azure AD App Registration, these are samples that show the typings for those objects:
+
+```TypeScript
+import { Configuration, AuthenticationParameters } from "msal";
+
+const configuration: Configuration = {
+  auth: {
+    authority: "https://login.microsoftonline.com/{tenant Id}/",
+    clientId: "{AAD Application Id/Client Id}"
+  }
+};
+
+const authParams: AuthenticationParameters = {
+  scopes: ["https://graph.microsoft.com/.default"] 
+};
+```
+
+## MSAL + Browser
+
+```TypeScript
+import { spfi, SPBrowser } from "@pnp/sp";
+import { graphfi, GraphBrowser } from "@pnp/graph";
+import { MSAL } from "@pnp/msaljsclient";
+import "@pnp/sp/webs";
+import "@pnp/graph/users";
+
+const sp = spfi("https://tenant.sharepoint.com/sites/dev").using(SPBrowser(), MSAL(configuration, authParams));
+
+// within a webpart, application customizer, or adaptive card extension where the context object is available
+const graph = graphfi().using(GraphBrowser(), MSAL(configuration, authParams));
+
+const webData = await sp.web();
+const meData = await graph.me();
+```

package/docs/concepts/auth-nodejs.md

@@ -0,0 +1,101 @@
+# Authentication in NodeJS
+
+We support MSAL for both browser and nodejs and Azure Identity for nodejs by providing a thin wrapper around the official libraries. We won't document the fully possible configurations, but any parameters supplied are passed through to the underlying implementation.
+
+Depending on which package you want to use you will need to install an additional package from the library because of the large dependencies.
+
+We support MSAL through the [msal-node](https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-node/README.md) library which is included by the @pnp/nodejs package.
+
+For the Azure Identity package:
+
+`npm install @pnp/azidjsclient --save`
+
+We support Azure Identity through the [@azure/identity](https://github.com/Azure/azure-sdk-for-js/blob/main/documentation/using-azure-identity.md) library which simplifies the authentication process and makes it easy to integrate Azure Identity authentication in your solution.
+
+## MSAL + NodeJS
+
+The SPDefault and GraphDefault exported by the nodejs library include MSAL and takes the parameters directly.
+
+The following samples reference a MSAL configuration that utilizes an Azure AD App Registration, these are samples that show the typings for those objects:
+
+```TypeScript
+import { SPDefault, GraphDefault } from "@pnp/nodejs";
+import { spfi } from "@pnp/sp";
+import { graphfi } from "@pnp/graph";
+import { Configuration, AuthenticationParameters } from "msal";
+import "@pnp/graph/users";
+import "@pnp/sp/webs";
+
+const configuration: Configuration = {
+  auth: {
+    authority: "https://login.microsoftonline.com/{tenant Id}/",
+    clientId: "{AAD Application Id/Client Id}"
+  }
+};
+
+const sp = spfi("{site url}").using(SPDefault({
+    msal: {
+        config: configuration,
+        scopes: ["https://{tenant}.sharepoint.com/.default"],
+    },
+}));
+
+const graph = graphfi().using(GraphDefault({
+    msal: {
+        config: configuration,
+        scopes: ["https://graph.microsoft.com/.default"],
+    },
+}));
+
+const webData = await sp.web();
+const meData = await graph.me();
+```
+
+## Use Nodejs MSAL behavior directly
+
+It is also possible to use the MSAL behavior directly if you are composing your own strategies.
+
+```TypeScript
+import { SPDefault, GraphDefault, MSAL } from "@pnp/nodejs";
+
+const sp = spfi("{site url}").using(SPDefault(), MSAL({
+  config: configuration,
+  scopes: ["https://{tenant}.sharepoint.com/.default"],
+}));
+
+const graph = graphfi().using(GraphDefault(), MSAL({
+  config: configuration,
+  scopes: ["https://graph.microsoft.com/.default"],
+}));
+
+```
+
+## Azure Identity + NodeJS
+
+The following sample shows how to pass the credential object to the AzureIdentity behavior including scopes.
+
+```TypeScript
+import { DefaultAzureCredential } from "@azure/identity";
+import { spfi } from "@pnp/sp";
+import { graphfi } from "@pnp/sp";
+import { SPDefault, GraphDefault } from "@pnp/nodejs";
+import { AzureIdentity } from "@pnp/azidjsclient";
+import "@pnp/sp/webs";
+import "@pnp/graph/users";
+
+// We're using DefaultAzureCredential but the credential can be any valid `Credential Type`
+const credential = new DefaultAzureCredential();
+
+const sp = spfi("https://{tenant}.sharepoint.com/sites/dev").using(
+    SPDefault(),
+    AzureIdentity(credential, [`https://${tenant}.sharepoint.com/.default`], null)
+);
+
+const graph = graphfi().using(
+    GraphDefault(),
+    AzureIdentity(credential, ["https://graph.microsoft.com/.default"], null)
+);
+
+const webData = await sp.web();
+const meData = await graph.me();
+```

package/docs/concepts/auth-spfx.md

@@ -0,0 +1,76 @@
+# Authentication in SharePoint Framework
+
+When building in SharePoint Framework you only need to provide the context to either sp or graph to ensure proper authentication. This will use the default [SharePoint AAD application](https://docs.microsoft.com/en-us/sharepoint/dev/spfx/use-aadhttpclient) to manage scopes. If you would prefer to use a different AAD application please see the MSAL section below.
+
+## SPFx + SharePoint
+
+```TypeScript
+import { SPFx, spfi } from "@pnp/sp";
+import "@pnp/sp/webs";
+
+// within a webpart, application customizer, or adaptive card extension where the context object is available
+const sp = spfi().using(SPFx(this.context));
+
+const webData = await sp.web();
+```
+
+## SPFx + Graph
+
+```TypeScript
+import { SPFx, graphfi } from "@pnp/graph";
+import "@pnp/graph/users";
+
+// within a webpart, application customizer, or adaptive card extension where the context object is available
+const graph = graphfi().using(SPFx(this.context));
+
+const meData = await graph.me();
+```
+
+## SPFx + Authentication Token
+
+When using the SPFx behavior, authentication is handled by a cookie stored on the users client. In very specific instances some of the SharePoint methods will require a token. We have added a custom behavior to support that called `SPFxToken`. This will require that you add the appropriate application role to the SharePoint Framework's `package-solution.json` -> webApiPermissionRequests section where you will [define the resource and scope for the request](https://learn.microsoft.com/en-us/sharepoint/dev/spfx/use-aadhttpclient#request-permissions-to-an-azure-ad-application).
+
+Here's an example of how you would build an instance of the SPFI that would include an Bearer Token in the header. Be advised if you use this instance to make calls to SharePoint endpoints that you have not specifically authorized they will fail.
+
+```TypeScript
+import { spfi, SPFxToken, SPFx } from "@pnp/sp";
+
+const sp = spfi().using(SPFx(context), SPFxToken(context));
+```
+
+## MSAL + SPFx
+
+We support MSAL for both browser and nodejs by providing a thin wrapper around the official libraries. We won't document the fully possible MSAL configuration, but any parameters supplied are passed through to the underlying implementation. To use the browser MSAL package you'll need to install the @pnp/msaljsclient package which is deployed as a standalone due to the large MSAL dependency.
+
+`npm install @pnp/msaljsclient --save`
+
+At this time we're using version 1.x of the `msal` library which uses Implicit Flow. For more informaiton on the msal library please see the [AzureAD/microsoft-authentication-library-for-js](https://github.com/AzureAD/microsoft-authentication-library-for-js#readme).
+
+Each of the following samples reference a MSAL configuration that utilizes an Azure AD App Registration, these are samples that show the typings for those objects:
+
+```TypeScript
+import { SPFx as graphSPFx, graphfi } from "@pnp/graph";
+import { SPFx as spSPFx, spfi } from "@pnp/sp";
+import { MSAL } from "@pnp/msaljsclient";
+import { Configuration, AuthenticationParameters } from "msal";
+import "@pnp/graph/users";
+import "@pnp/sp/webs";
+
+const configuration: Configuration = {
+  auth: {
+    authority: "https://login.microsoftonline.com/{tenant Id}/",
+    clientId: "{AAD Application Id/Client Id}"
+  }
+};
+
+const authParams: AuthenticationParameters = {
+  scopes: ["https://graph.microsoft.com/.default"] 
+};
+
+// within a webpart, application customizer, or adaptive card extension where the context object is available
+const graph = graphfi().using(graphSPFx(this.context), MSAL(configuration, authParams));
+const sp = spfi().using(spSPFx(this.context), MSAL(configuration, authParams));
+
+const meData = await graph.me();
+const webData = await sp.web();
+```

package/docs/concepts/authentication.md

@@ -0,0 +1,42 @@
+# Authentication
+
+One of the more challenging aspects of web development is ensuring you are properly authenticated to access the resources you need. This section is designed to guide you through connecting to the resources you need using the appropriate methods.
+
+We provide multiple ways to authenticate based on the scenario you're developing for, see one of these more detailed guides:
+
+- [Authentication in SharePoint Framework](./auth-spfx.md)
+- [Authentication in a custom browser based application (Outside Microsoft 365)](./auth-browser.md)
+- [Authentication in NodeJS](./auth-nodejs.md)
+
+If you have more specific authentication requirements you can always build your own by using the new [queryable](../queryable/queryable.md) pattern which exposes a dedicated [auth moment](../queryable/queryable.md#auth). That moment expects observers with the signature:
+
+```TypeScript
+async function(url, init) {
+
+  // logic to apply authentication to the request
+
+    return [url, init];
+}
+```
+
+You can follow this example as a general pattern to build your own custom authentication model. You can then wrap your authentication in a [behavior](../core/behaviors.md) for easy reuse.
+
+```TypeScript
+import { spfi } from "@pnp/sp";
+import "@pnp/sp/webs";
+
+const sp = spfi().using({behaviors});
+const web = sp.web;
+
+// we will use custom auth on this web
+web.on.auth(async function(url, init) {
+
+    // some code to get a token
+    const token = getToken();
+
+    // set the Authorization header in the init (this init is what is passed directly to the fetch call)
+    init.headers["Authorization"] = `Bearer ${token}`;
+
+    return [url, init];
+});
+```

package/docs/concepts/batching-caching.md

@@ -0,0 +1,77 @@
+# Batching and Caching
+
+When optimizing for performance you can combine [batching](batching.md) and [caching](../queryable/behaviors.md#caching) to reduce the overall number of requests. On the first request any cachable data is stored as expected once the request completes. On subsequent requests if data is found in the cache it is returned immediately and that request is not added to the batch, in fact the batch will never register the request. This can work across many requests such that some returned cached data and others do not - the non-cached requests will be added to and processed by the batch as expected.
+
+```TypeScript
+import { spfi } from "@pnp/sp";
+import "@pnp/sp/webs";
+import "@pnp/sp/lists";
+import { Caching } from "@pnp/queryable";
+
+const sp = spfi(...);
+
+const [batchedSP, execute] = sp.batched();
+
+batchedSP.using(Caching());
+
+batchedSP.web().then(console.log);
+
+batchedSP.web.lists().then(console.log);
+
+// execute the first set of batched requests, no information is currently cached
+await execute();
+
+// create a new batch
+const [batchedSP2, execute2] = await sp.batched();
+batchedSP2.using(Caching());
+
+// add the same requests - this simulates the user navigating away from or reloading the page
+batchedSP2.web().then(console.log);
+batchedSP2.web.lists().then(console.log);
+
+// executing the batch will return the cached values from the initial requests
+await execute2();
+```
+
+In this second example we include an update to the web's title. Because non-get requests are never cached the update code will always run, but the results from the two get requests will resolve from the cache prior to being added to the batch.
+
+```TypeScript
+import { spfi } from "@pnp/sp";
+import "@pnp/sp/webs";
+import "@pnp/sp/lists";
+import { Caching } from "@pnp/queryable";
+
+const sp = spfi(...);
+
+const [batchedSP, execute] = sp.batched();
+
+batchedSP.using(Caching());
+
+batchedSP.web().then(console.log);
+
+batchedSP.web.lists().then(console.log);
+
+// this will never be cached
+batchedSP.web.update({
+    Title: "dev web 1",
+});
+
+// execute the first set of batched requests, no information is currently cached
+await execute();
+
+// create a new batch
+const [batchedSP2, execute2] = await sp.batched();
+batchedSP2.using(Caching());
+
+// add the same requests - this simulates the user navigating away from or reloading the page
+batchedSP2.web().then(console.log);
+batchedSP2.web.lists().then(console.log);
+
+// this will never be cached
+batchedSP2.web.update({
+    Title: "dev web 2",
+});
+
+// executing the batch will return the cached values from the initial requests
+await execute2();
+```