@salesforce/lds-runtime-mobile 1.100.2

package/sfdc/priming/primingSessionFactory.d.ts

@@ -0,0 +1,13 @@
+import { PrimingSession } from '@salesforce/lds-priming';
+import type { Luvio, NetworkAdapter } from '@luvio/engine';
+import type { NimbusSqliteStore } from '../durableStore/NimbusSqliteStore/NimbusSqliteStore';
+import type { ObjectInfoService } from '../main';
+export interface PrimingSessionFactoryConfig {
+    store: NimbusSqliteStore;
+    networkAdapter: NetworkAdapter;
+    objectInfoService: ObjectInfoService;
+    getLuvio: () => Luvio;
+    concurrency?: number;
+    batchSize?: number;
+}
+export declare function primingSessionFactory(config: PrimingSessionFactoryConfig): PrimingSession;

package/sfdc/runtime.d.ts

@@ -0,0 +1,17 @@
+import { Luvio } from '@luvio/engine';
+import { DraftManager } from '@salesforce/lds-drafts';
+import type { DraftQueue } from '@salesforce/lds-drafts';
+import type { PrimingSession } from '@salesforce/lds-priming';
+export interface Runtime {
+    luvio: Luvio;
+    draftQueue: DraftQueue;
+    draftManager: DraftManager;
+    createPrimingSession: (config: {
+        concurrency?: number;
+        batchSize?: number;
+    }) => PrimingSession;
+}
+/**
+ * This returns the LDS on Mobile Runtime singleton object.
+ */
+export declare function getRuntime(): Runtime;

package/sfdc/utils/ObjectInfoService.d.ts

@@ -0,0 +1,43 @@
+import type { Adapter } from '@luvio/engine';
+import type { DurableStore } from '@luvio/environments';
+import type { ObjectInfoRepresentation, SimplifiedBatchRepresentation, getObjectInfoAdapterFactory, getObjectInfosAdapterFactory } from '@salesforce/lds-adapters-uiapi';
+export declare const OBJECT_INFO_PREFIX_SEGMENT = "OBJECT_INFO_PREFIX_SEGMENT";
+export interface ObjectInfoIndex {
+    apiName: string;
+    keyPrefix: string | null;
+}
+type ObjectInfoAdapterReturn = ReturnType<typeof getObjectInfoAdapterFactory>;
+type ObjectInfosAdapterReturn = ReturnType<typeof getObjectInfosAdapterFactory>;
+type ObjectInfoConfig = Parameters<ObjectInfoAdapterReturn>[0];
+type ObjectInfosConfig = Parameters<ObjectInfosAdapterReturn>[0];
+export type ObjectInfoMap = {
+    [apiName: string]: ObjectInfoRepresentation;
+};
+export declare class ObjectInfoService {
+    private getObjectInfoAdapter;
+    private getObjectInfosAdapter;
+    private durableStore;
+    objectInfoMemoryCache: {
+        [apiName: string]: string | null;
+    };
+    constructor(getObjectInfoAdapter: Adapter<ObjectInfoConfig, ObjectInfoRepresentation>, getObjectInfosAdapter: Adapter<ObjectInfosConfig, SimplifiedBatchRepresentation>, durableStore: DurableStore);
+    apiNameForPrefix: (prefix: string) => Promise<string>;
+    /**
+     * Size of return map not necessarily correlated with number of inputs.  The
+     * ObjectInfoMap returned will only be populated with values of apiNames returned
+     * from the adapter.
+     */
+    getObjectInfos(apiNames: string[]): Promise<ObjectInfoMap>;
+    ensureObjectInfoCached: (apiName: string, entry?: ObjectInfoRepresentation) => Promise<void>;
+    /**
+     * Caches ObjectInfo(ApiName and KeyPrefix) in Durable Store
+     *
+     * @param apiName eg: 'Account'
+     * @param objectInfo Object Info
+     *
+     * @returns Promise
+     */
+    private createObjectInfoMapping;
+    private isObjectInfoInDurableStore;
+}
+export {};

package/sfdc/utils/adapters.d.ts

@@ -0,0 +1,18 @@
+import type { InMemoryStore, NetworkAdapter } from '@luvio/engine';
+import { Luvio } from '@luvio/engine';
+import type { DurableStore } from '@luvio/environments';
+import type { EnsureCachedObjectInfoFunction } from '../environment/enableLazyObjectInfoCaching';
+/**
+Builds adapter instances for environments that have cross-adapter dependencies.
+These are only to be used internally in this module and not exported.
+They do not use draft environments, just the makeDurable environment.
+*/
+export declare function buildInternalAdapters(store: InMemoryStore, networkAdapter: NetworkAdapter, durableStore: DurableStore, ensureObjectInfoCached: EnsureCachedObjectInfoFunction): {
+    luvio: Luvio;
+    durableEnvironment: import("@luvio/environments").DurableEnvironment;
+    adapters: {
+        getRecord: import("@luvio/engine").Adapter<import("@salesforce/lds-adapters-uiapi").GetRecordConfig, import("@salesforce/lds-adapters-uiapi").RecordRepresentation>;
+        getObjectInfo: import("@luvio/engine").Adapter<import("@salesforce/lds-adapters-uiapi").GetObjectInfoConfig, import("@salesforce/lds-adapters-uiapi").ObjectInfoRepresentation>;
+        getObjectInfos: import("@luvio/engine").Adapter<import("@salesforce/lds-adapters-uiapi/dist/types/src/generated/adapters/getObjectInfos").GetObjectInfosConfig, import("@salesforce/lds-adapters-uiapi").SimplifiedBatchRepresentation>;
+    };
+};

package/sfdc/utils/language.d.ts

@@ -0,0 +1,29 @@
+declare const keys: {
+    (o: object): string[];
+    (o: {}): string[];
+}, create: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+}, assign: {
+    <T extends {}, U>(target: T, source: U): T & U;
+    <T_1 extends {}, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
+    <T_2 extends {}, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W;
+    (target: object, ...sources: any[]): any;
+}, entries: {
+    <T>(o: {
+        [s: string]: T;
+    } | ArrayLike<T>): [string, T][];
+    (o: {}): [string, any][];
+};
+declare const stringify: {
+    (value: any, replacer?: ((this: any, key: string, value: any) => any) | undefined, space?: string | number | undefined): string;
+    (value: any, replacer?: (string | number)[] | null | undefined, space?: string | number | undefined): string;
+}, parse: (text: string, reviver?: ((this: any, key: string, value: any) => any) | undefined) => any;
+declare const push: (...items: any[]) => number, join: (separator?: string | undefined) => string, slice: (start?: number | undefined, end?: number | undefined) => any[];
+declare const isArray: (arg: any) => arg is any[], from: {
+    <T>(arrayLike: ArrayLike<T>): T[];
+    <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+    <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+    <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+};
+export { keys as ObjectKeys, create as ObjectCreate, assign as ObjectAssign, entries as ObjectEntries, push as ArrayPrototypePush, join as ArrayPrototypeJoin, slice as ArrayPrototypeSlice, isArray as ArrayIsArray, from as ArrayFrom, stringify as JSONStringify, parse as JSONParse, };

package/sfdc/utils/utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A deterministic JSON stringify implementation. Heavily adapted from https://github.com/epoberezkin/fast-json-stable-stringify.
+ * This is needed because insertion order for JSON.stringify(object) affects output:
+ * JSON.stringify({a: 1, b: 2})
+ *      "{"a":1,"b":2}"
+ * JSON.stringify({b: 2, a: 1})
+ *      "{"b":2,"a":1}"
+ * Modified from the apex implementation to sort arrays non-destructively.
+ * @param data Data to be JSON-stringified.
+ * @returns JSON.stringified value with consistent ordering of keys.
+ */
+export declare function stableJSONStringify(node: any): string | undefined;
+export declare function isPromise<D>(value: D | Promise<D> | null): value is Promise<D>;