@jitsu/js 1.9.18-canary.1269.20250403142744 → 1.9.18-canary.1288.20250415191203

package/package/dist/method-queue.d.ts

@@ -0,0 +1,19 @@
+export type InterfaceWrapper<T> = {
+  get(): WithAsyncMethods<T>;
+  loaded(instance: T): any;
+};
+type WithAsyncMethods<T> = {
+  [K in keyof T]: T[K] extends (...args: infer A) => infer R
+    ? (...args: A) => R extends Promise<any> ? R : Promise<R>
+    : T[K];
+};
+/**
+ * This function creates a wrapper around an interface that allows to call methods on it, but all methods will go to queue. Once actual instance
+ * implementation becomes available, all queued methods will be called on it.
+ *
+ *
+ * @param methods of methods that should be wrapped. Per each method of you should specify if it should be wrapped. You'll need to mark all
+ * methods for type safety. If method is not wrapped, it will throw an error when called.
+ */
+export declare function delayMethodExec<T>(methods: Record<keyof T, boolean>): InterfaceWrapper<T>;
+export {};

package/package/dist/script-loader.d.ts

@@ -0,0 +1,8 @@
+export type ScriptOptions = {
+  attributes?: Record<string, string>;
+  www?: boolean;
+  js?: boolean;
+  min?: boolean;
+  query?: string;
+};
+export declare function loadScript(src: string, options?: ScriptOptions): Promise<HTMLScriptElement>;

package/package/dist/tlds.d.ts

@@ -0,0 +1,3 @@
+export declare const publicSuffixes: string[];
+export declare const publicSuffixesMap: Record<string, boolean>;
+export declare function getTopLevelDomain(hostname: string): string;

package/package/dist/version.d.ts

@@ -0,0 +1,3 @@
+declare const jitsuVersion: string;
+declare const jitsuLibraryName = "@jitsu/js";
+export { jitsuVersion, jitsuLibraryName };