@wix/cache 1.0.4 → 1.0.6

package/build/cjs/index.d.ts

@@ -1 +1,2 @@
-export * as cache from '@wix/cache_cache';
+import * as cache from '@wix/cache_cache';
+export { cache };

package/build/cjs/index.js

@@ -24,5 +24,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cache = void 0;
-exports.cache = __importStar(require("@wix/cache_cache"));
+const cache = __importStar(require("@wix/cache_cache"));
+exports.cache = cache;
 //# sourceMappingURL=index.js.map

package/build/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,0DAA0C"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wDAA0C;AAEjC,sBAAK"}

package/build/es/index.d.ts

@@ -1 +1,2 @@
-export * as cache from '@wix/cache_cache';
+import * as cache from '@wix/cache_cache';
+export { cache };

package/build/es/index.js

@@ -1,2 +1,3 @@
-export * as cache from '@wix/cache_cache';
+import * as cache from '@wix/cache_cache';
+export { cache };
 //# sourceMappingURL=index.js.map

package/build/es/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC;AAE1C,OAAO,EAAE,KAAK,EAAE,CAAC"}

package/context/package.json

@@ -2,5 +2,6 @@
   "sideEffects": false,
   "module": "../build/es/context.js",
   "main": "../build/cjs/context.js",
-  "typings": "../build/cjs/context.d.ts"
+  "typings": "../build/cjs/context.d.ts",
+  "typesBundle": "../type-bundles/context.bundle.d.ts"
 }

package/meta/package.json

@@ -2,5 +2,6 @@
   "sideEffects": false,
   "module": "../build/es/meta.js",
   "main": "../build/cjs/meta.js",
-  "typings": "../build/cjs/meta.d.ts"
+  "typings": "../build/cjs/meta.d.ts",
+  "typesBundle": "../type-bundles/meta.bundle.d.ts"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/cache",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
@@ -9,21 +9,27 @@
   "module": "build/es/index.js",
   "main": "build/cjs/index.js",
   "typings": "./build/cjs/index.d.ts",
+  "typesBundle": "./type-bundles/index.bundle.d.ts",
   "files": [
     "build",
     "frontend/package.json",
     "meta",
-    "context"
+    "context",
+    "type-bundles"
   ],
   "dependencies": {
-    "@wix/cache_cache": "1.0.4"
+    "@wix/cache_cache": "1.0.6"
   },
   "devDependencies": {
-    "@wix/sdk": "https://cdn.dev.wixpress.com/@wix/sdk/02e8069ab2fd783e0e6a080fc7d590e76cb26ab93c8389574286305b.tar.gz",
+    "glob": "^10.4.1",
+    "rollup": "^4.18.0",
+    "rollup-plugin-dts": "^6.1.1",
     "typescript": "^5.3.2"
   },
   "scripts": {
-    "build": "tsc -b tsconfig.json tsconfig.esm.json",
+    "build": "tsc -b tsconfig.json tsconfig.esm.json && npm run build:dts-bundles && npm run build:validate-dts",
+    "build:dts-bundles": "test -f config/rollup-config.js && NODE_OPTIONS=--max-old-space-size=8192 rollup --config config/rollup-config.js || echo 'Warning: config/rollup-config.js not found!'",
+    "build:validate-dts": "tsc type-bundles/*.d.ts --noEmit",
     "test": ":"
   },
   "wix": {
@@ -37,5 +43,5 @@
       "fqdn": ""
     }
   },
-  "falconPackageHash": "d2ed6b0beb17b045cd7b7f50298657454d8a6a64bb7f8936c1ae7dc9"
+  "falconPackageHash": "f03674336942a82ba8490548a0256d05b3c7ac3ec5a44ab3f44aa237"
 }

package/type-bundles/context.bundle.d.ts

@@ -0,0 +1,89 @@
+type RESTFunctionDescriptor<T extends (...args: any[]) => any = (...args: any[]) => any> = (httpClient: HttpClient) => T;
+interface HttpClient {
+    request<TResponse, TData = any>(req: RequestOptionsFactory<TResponse, TData>): Promise<HttpResponse<TResponse>>;
+    fetchWithAuth: typeof fetch;
+    wixAPIFetch: (relativeUrl: string, options: RequestInit) => Promise<Response>;
+}
+type RequestOptionsFactory<TResponse = any, TData = any> = (context: any) => RequestOptions<TResponse, TData>;
+type HttpResponse<T = any> = {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: any;
+    request?: any;
+};
+type RequestOptions<_TResponse = any, Data = any> = {
+    method: 'POST' | 'GET' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+    url: string;
+    data?: Data;
+    params?: URLSearchParams;
+} & APIMetadata;
+type APIMetadata = {
+    methodFqn?: string;
+    entityFqdn?: string;
+    packageName?: string;
+};
+type BuildRESTFunction<T extends RESTFunctionDescriptor> = T extends RESTFunctionDescriptor<infer U> ? U : never;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+interface InvalidateCacheRequest {
+    /** An array of objects containing a `tag` field used to identify the cache to invalidate. All cached return values with any listed tags are invalidated. If no tags are specified, nothing is invalidated. */
+    invalidationMethods?: InvalidationMethods[];
+}
+interface InvalidationMethods extends InvalidationMethodsInvalidateByOneOf {
+    /** Identifiers of the caches to invalidate. */
+    tag?: string;
+}
+/** @oneof */
+interface InvalidationMethodsInvalidateByOneOf {
+    /** Identifiers of the caches to invalidate. */
+    tag?: string;
+}
+interface InvalidateCacheResponse {
+}
+
+declare function invalidateCache$1(httpClient: HttpClient): InvalidateCacheSignature;
+interface InvalidateCacheSignature {
+    /**
+     * Clears caches using specified tags.
+     *
+     * This function invalidates or clears previously cached return values based on specified tags. The `invalidationMethods` parameter accepts an array of objects, each containing a `tag` field. These tags are defined when caching return values for routers using the [`ok()` function](https://dev.wix.com/docs/velo/api-reference/wix-router/ok). For example, an array such as `[{ tag: "contacts" }, { tag: "labels" }]` will clear any cached return values tagged with "contacts" or "labels." Any cache containing at least one tag specified in the `invalidationMethods` parameter will be cleared.
+     *
+     *
+     * <blockquote class="important">
+     *
+     * __Important:__
+     * - If you don't specify any tags in the `invalidationsMethod` parameter, no caches are invalidated.
+     * - If you don't use the `invalidateCache()` function, your caches are only invalidated when the Time to Live (TTL) expires or when you republish your site with a code change.
+     *
+     *
+     * - This function invalidates router caches. To invalidate the Server Side Rendering (SSR) cache for your site, use the `invalidateCache()` function from the [`wix-site-backend`](https://dev.wix.com/docs/velo/api-reference/wix-site-backend/invalidate-cache) module.
+     *
+     * </blockquote>
+     * @param - An array of objects containing a `tag` field used to identify the cache to invalidate. All cached return values with any listed tags are invalidated. If no tags are specified, nothing is invalidated.
+     */
+    (invalidationMethods: InvalidationMethods[]): Promise<void>;
+}
+
+declare function createRESTModule<T extends RESTFunctionDescriptor>(descriptor: T, elevated?: boolean): BuildRESTFunction<T> & T;
+
+type _publicInvalidateCacheType = typeof invalidateCache$1;
+declare const invalidateCache: ReturnType<typeof createRESTModule<_publicInvalidateCacheType>>;
+
+type context_InvalidateCacheRequest = InvalidateCacheRequest;
+type context_InvalidateCacheResponse = InvalidateCacheResponse;
+type context_InvalidationMethods = InvalidationMethods;
+type context_InvalidationMethodsInvalidateByOneOf = InvalidationMethodsInvalidateByOneOf;
+type context__publicInvalidateCacheType = _publicInvalidateCacheType;
+declare const context_invalidateCache: typeof invalidateCache;
+declare namespace context {
+  export { type context_InvalidateCacheRequest as InvalidateCacheRequest, type context_InvalidateCacheResponse as InvalidateCacheResponse, type context_InvalidationMethods as InvalidationMethods, type context_InvalidationMethodsInvalidateByOneOf as InvalidationMethodsInvalidateByOneOf, type context__publicInvalidateCacheType as _publicInvalidateCacheType, context_invalidateCache as invalidateCache };
+}
+
+export { context as cache };

package/type-bundles/index.bundle.d.ts

@@ -0,0 +1,89 @@
+type RESTFunctionDescriptor<T extends (...args: any[]) => any = (...args: any[]) => any> = (httpClient: HttpClient) => T;
+interface HttpClient {
+    request<TResponse, TData = any>(req: RequestOptionsFactory<TResponse, TData>): Promise<HttpResponse<TResponse>>;
+    fetchWithAuth: typeof fetch;
+    wixAPIFetch: (relativeUrl: string, options: RequestInit) => Promise<Response>;
+}
+type RequestOptionsFactory<TResponse = any, TData = any> = (context: any) => RequestOptions<TResponse, TData>;
+type HttpResponse<T = any> = {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: any;
+    request?: any;
+};
+type RequestOptions<_TResponse = any, Data = any> = {
+    method: 'POST' | 'GET' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+    url: string;
+    data?: Data;
+    params?: URLSearchParams;
+} & APIMetadata;
+type APIMetadata = {
+    methodFqn?: string;
+    entityFqdn?: string;
+    packageName?: string;
+};
+type BuildRESTFunction<T extends RESTFunctionDescriptor> = T extends RESTFunctionDescriptor<infer U> ? U : never;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+interface InvalidateCacheRequest {
+    /** An array of objects containing a `tag` field used to identify the cache to invalidate. All cached return values with any listed tags are invalidated. If no tags are specified, nothing is invalidated. */
+    invalidationMethods?: InvalidationMethods[];
+}
+interface InvalidationMethods extends InvalidationMethodsInvalidateByOneOf {
+    /** Identifiers of the caches to invalidate. */
+    tag?: string;
+}
+/** @oneof */
+interface InvalidationMethodsInvalidateByOneOf {
+    /** Identifiers of the caches to invalidate. */
+    tag?: string;
+}
+interface InvalidateCacheResponse {
+}
+
+declare function invalidateCache$1(httpClient: HttpClient): InvalidateCacheSignature;
+interface InvalidateCacheSignature {
+    /**
+     * Clears caches using specified tags.
+     *
+     * This function invalidates or clears previously cached return values based on specified tags. The `invalidationMethods` parameter accepts an array of objects, each containing a `tag` field. These tags are defined when caching return values for routers using the [`ok()` function](https://dev.wix.com/docs/velo/api-reference/wix-router/ok). For example, an array such as `[{ tag: "contacts" }, { tag: "labels" }]` will clear any cached return values tagged with "contacts" or "labels." Any cache containing at least one tag specified in the `invalidationMethods` parameter will be cleared.
+     *
+     *
+     * <blockquote class="important">
+     *
+     * __Important:__
+     * - If you don't specify any tags in the `invalidationsMethod` parameter, no caches are invalidated.
+     * - If you don't use the `invalidateCache()` function, your caches are only invalidated when the Time to Live (TTL) expires or when you republish your site with a code change.
+     *
+     *
+     * - This function invalidates router caches. To invalidate the Server Side Rendering (SSR) cache for your site, use the `invalidateCache()` function from the [`wix-site-backend`](https://dev.wix.com/docs/velo/api-reference/wix-site-backend/invalidate-cache) module.
+     *
+     * </blockquote>
+     * @param - An array of objects containing a `tag` field used to identify the cache to invalidate. All cached return values with any listed tags are invalidated. If no tags are specified, nothing is invalidated.
+     */
+    (invalidationMethods: InvalidationMethods[]): Promise<void>;
+}
+
+declare function createRESTModule<T extends RESTFunctionDescriptor>(descriptor: T, elevated?: boolean): BuildRESTFunction<T> & T;
+
+type _publicInvalidateCacheType = typeof invalidateCache$1;
+declare const invalidateCache: ReturnType<typeof createRESTModule<_publicInvalidateCacheType>>;
+
+type index_d_InvalidateCacheRequest = InvalidateCacheRequest;
+type index_d_InvalidateCacheResponse = InvalidateCacheResponse;
+type index_d_InvalidationMethods = InvalidationMethods;
+type index_d_InvalidationMethodsInvalidateByOneOf = InvalidationMethodsInvalidateByOneOf;
+type index_d__publicInvalidateCacheType = _publicInvalidateCacheType;
+declare const index_d_invalidateCache: typeof invalidateCache;
+declare namespace index_d {
+  export { type index_d_InvalidateCacheRequest as InvalidateCacheRequest, type index_d_InvalidateCacheResponse as InvalidateCacheResponse, type index_d_InvalidationMethods as InvalidationMethods, type index_d_InvalidationMethodsInvalidateByOneOf as InvalidationMethodsInvalidateByOneOf, type index_d__publicInvalidateCacheType as _publicInvalidateCacheType, index_d_invalidateCache as invalidateCache };
+}
+
+export { index_d as cache };

package/type-bundles/meta.bundle.d.ts

@@ -0,0 +1,51 @@
+interface InvalidateCacheRequest$1 {
+    /** An array of objects containing a `tag` field used to identify the cache to invalidate. All cached return values with any listed tags are invalidated. If no tags are specified, nothing is invalidated. */
+    invalidationMethods?: InvalidationMethods$1[];
+}
+interface InvalidationMethods$1 extends InvalidationMethodsInvalidateByOneOf$1 {
+    /** Identifiers of the caches to invalidate. */
+    tag?: string;
+}
+/** @oneof */
+interface InvalidationMethodsInvalidateByOneOf$1 {
+    /** Identifiers of the caches to invalidate. */
+    tag?: string;
+}
+interface InvalidateCacheResponse$1 {
+}
+
+interface InvalidateCacheRequest {
+    /** An array of objects containing a `tag` field used to identify the cache to invalidate. All cached return values with any listed tags are invalidated. If no tags are specified, nothing is invalidated. */
+    invalidationMethods?: InvalidationMethods[];
+}
+interface InvalidationMethods extends InvalidationMethodsInvalidateByOneOf {
+    /** Identifiers of the caches to invalidate. */
+    tag?: string;
+}
+/** @oneof */
+interface InvalidationMethodsInvalidateByOneOf {
+    /** Identifiers of the caches to invalidate. */
+    tag?: string;
+}
+interface InvalidateCacheResponse {
+}
+
+type __PublicMethodMetaInfo<K = string, M = unknown, T = unknown, S = unknown, Q = unknown, R = unknown> = {
+    getUrl: (context: any) => string;
+    httpMethod: K;
+    path: string;
+    pathParams: M;
+    __requestType: T;
+    __originalRequestType: S;
+    __responseType: Q;
+    __originalResponseType: R;
+};
+declare function invalidateCache(): __PublicMethodMetaInfo<'POST', {}, InvalidateCacheRequest, InvalidateCacheRequest$1, InvalidateCacheResponse, InvalidateCacheResponse$1>;
+
+type meta___PublicMethodMetaInfo<K = string, M = unknown, T = unknown, S = unknown, Q = unknown, R = unknown> = __PublicMethodMetaInfo<K, M, T, S, Q, R>;
+declare const meta_invalidateCache: typeof invalidateCache;
+declare namespace meta {
+  export { type meta___PublicMethodMetaInfo as __PublicMethodMetaInfo, meta_invalidateCache as invalidateCache };
+}
+
+export { meta as cache };