@plaudit/gutenberg-api-extensions 2.95.0 → 2.97.0

package/src/lib/sectioned-cache-store.ts

@@ -1,120 +0,0 @@
-import {createReduxStore} from "@wordpress/data";
-
-import {TemporalLRUCache} from "./helpers";
-import {use, type WrappedPromise, wrapPromise} from "./suspense/promise-handlers";
-
-type SelectorsBuilder<
-	PROPS,
-	DATA,
-	SELECTORS extends { [name in string]: (...args: any[]) => any }
-> = (handleCacheMiss: (props: PROPS) => Promise<SectionedCacheFetchResult<DATA>>) => SELECTORS;
-type SectionedCacheFetchResult<DATA> = {error?: false, data: DATA}|{error: true, data: string};
-type GetCacheForPropsFunction<PROPS, DATA, KEY> = (props: PROPS) => TemporalLRUCache<KEY, WrappedPromise<SectionedCacheFetchResult<DATA>>>;
-type WarmingPromiseGetter<PROPS, DATA, KEY> = (
-	storeChanged: () => void, props: FetchWarmingDataArgs<PROPS, DATA, KEY>[0], ...args: DropFirst<FetchWarmingDataArgs<PROPS, DATA, KEY>>
-) => WrappedPromise<void>|undefined;
-
-type SectionedCacheStoreArgs<
-	PROPS,
-	DATA,
-	KEY,
-	SELECTORS extends { [name in string]: (...args: any[]) => any }
-> = {
-	keyify: (props: PROPS) => KEY
-	name: string
-	selectorsBuilder: SelectorsBuilder<PROPS, DATA, SELECTORS>
-	getCacheForProps?: GetCacheForPropsFunction<PROPS, DATA, KEY>
-	getIndividualItemFetchPromise: (props: PROPS) => Promise<SectionedCacheFetchResult<DATA>>
-	getWarmingPromise: WarmingPromiseGetter<PROPS, DATA, KEY>
-}
-type AddBSStateArg<S extends {[name in string]: (...args: any[]) => any}> = {[name in keyof S]: (state: any, ...args: Parameters<S[name]>) => ReturnType<S[name]>};
-export function create<PROPS, DATA, KEY, SELECTORS extends { [name in string]: (...args: any[]) => any }>(
-	args: SectionedCacheStoreArgs<PROPS, DATA, KEY, SELECTORS>
-) {
-	type ReduxSelectors = AddBSStateArg<SELECTORS>;
-	const {getCacheForProps = makeDefaultCacheForPropsGetter(), getIndividualItemFetchPromise, getWarmingPromise, keyify, name, selectorsBuilder} = args;
-	return {
-		name,
-		instantiate: () => {
-			const listeners = new Set<() => void>();
-
-			const storeChanged = () => {
-				for (const listener of listeners) {
-					listener();
-				}
-			}
-
-			const warmCache = (props: PROPS) => {
-				const warmingPromise = getWarmingPromise(storeChanged, props, getCacheForProps, keyify);
-				if (warmingPromise !== undefined) {
-					return use(warmingPromise);
-				}
-			}
-
-			const fetchItemContents = async (props: PROPS) => {
-				try {
-					return await getIndividualItemFetchPromise(props);
-				} catch (err) {
-					return ({error: true, data: (err?.toString() as string|undefined) ?? "EMPTY_RESPONSE"} as const) satisfies SectionedCacheFetchResult<DATA>;
-				}
-			}
-
-			const handleCacheMiss = (props: PROPS): Promise<SectionedCacheFetchResult<DATA>> => {
-				const key = keyify(props);
-				warmCache(props);
-				const cache = getCacheForProps(props);
-				const existingPromise = cache.get(key);
-				if (existingPromise !== null) {
-					return existingPromise;
-				}
-				const res = wrapPromise(fetchItemContents(props));
-				res.finally(storeChanged);
-				cache.set(key, res);
-				return res;
-			}
-
-			const selectors = selectorsBuilder(handleCacheMiss);
-
-			return {
-				getSelectors: () => selectors,
-				getSuspendSelectors: () => selectors,
-				getActions: () => ({}),
-				subscribe: (listener: () => void) => {
-					listeners.add(listener);
-					return () => listeners.delete(listener);
-				}
-			};
-		}
-	} satisfies ReturnType<typeof createReduxStore<{}, {}, ReduxSelectors>> as ReturnType<typeof createReduxStore<{}, {}, ReduxSelectors>>;
-}
-
-function makeDefaultCacheForPropsGetter<PROPS, DATA, KEY>() {
-	const cache: ReturnType<GetCacheForPropsFunction<PROPS, DATA, KEY>> = new TemporalLRUCache(10);
-	return () => cache;
-}
-
-type DropFirst<A extends any[]> = A extends [any, ...infer R] ? R : never;
-type FetchWarmingDataArgs<PROPS, DATA, KEY> = [props: PROPS, getCacheForProps: GetCacheForPropsFunction<PROPS, DATA, KEY>, keyify: (props: PROPS) => KEY];
-type MakeSimpleWarmingPromisesGetterArgs<PROPS, DATA, KEY> = {
-	warmingPromisesKeyify: (props: PROPS) => string|number|undefined, // Returning undefined short-circuits the rest of the function, skipping any waiting at all
-	fetchWarmingData: (...args: FetchWarmingDataArgs<PROPS, DATA, KEY>) => Promise<void>,
-	shouldWarm?: ((props: PROPS) => boolean)
-};
-export function makeSimpleWarmingPromisesGetter<PROPS, DATA, KEY>(
-	{warmingPromisesKeyify, fetchWarmingData, shouldWarm = () => true}: MakeSimpleWarmingPromisesGetterArgs<PROPS, DATA, KEY>
-): WarmingPromiseGetter<PROPS, DATA, KEY> {
-	const warmingPromises: Record<string|number, WrappedPromise<void>> = {};
-	return (storeChanged, props, ...args) => {
-		const key = warmingPromisesKeyify(props);
-		if (key === undefined) {
-			return;
-		}
-		if (!warmingPromises[key]) {
-			if (!shouldWarm(props)) {
-				return; // We don't want to go back to the server for the entire dataset unless we're going to be working with most of it
-			}
-			warmingPromises[key] = wrapPromise(fetchWarmingData(props, ...args).finally(storeChanged));
-		}
-		return warmingPromises[key];
-	};
-}

package/src/lib/suspense/promise-handlers.ts

@@ -1,72 +0,0 @@
-type WrappedPromiseEnhancements<T> = {value: T, status: 'fulfilled'}|{reason: unknown, status: 'rejected'};
-export type WrappedPromise<T> = Promise<T>&({status: 'pending'}|WrappedPromiseEnhancements<T>);
-export type PartiallyWrappedPromise<T> = Promise<T>&({status?: 'pending'}|WrappedPromiseEnhancements<T>);
-export function isWrappedPromise<T>(promise: Promise<T>): promise is WrappedPromise<T> {
-	return 'status' in promise
-		&& (promise.status === 'pending' || (promise.status === 'fulfilled' && 'value' in promise) || (promise.status === 'rejected' && 'reason' in promise));
-}
-
-export function use<T>(promise: PartiallyWrappedPromise<T>): T {
-	switch (promise.status) {
-		case "pending":
-			throw promise;
-		case "fulfilled":
-			return promise.value;
-		case "rejected":
-			throw promise.reason;
-		default:
-			return use(actuallyWrapPromise(promise));
-	}
-}
-
-export function useImmediately<T>(promise: PartiallyWrappedPromise<T>): T|undefined {
-	switch (promise.status) {
-		case "pending":
-			return undefined;
-		case "fulfilled":
-			return promise.value;
-		case "rejected":
-			throw promise.reason;
-		default:
-			return useImmediately(actuallyWrapPromise(promise));
-	}
-}
-
-export function useToPromise<T>(promise: PartiallyWrappedPromise<T>): Promise<T> {
-	switch (promise.status) {
-		case "pending":
-			throw promise;
-		case "fulfilled":
-			return Promise.resolve(promise.value);
-		case "rejected":
-			throw promise.reason;
-		default:
-			return useToPromise(actuallyWrapPromise(promise));
-	}
-}
-
-export function wrapPromise<T>(promise: PartiallyWrappedPromise<T>): WrappedPromise<T> {
-	return isWrappedPromise(promise) ? promise : actuallyWrapPromise(promise);
-}
-function actuallyWrapPromise<T>(promise: PartiallyWrappedPromise<T>): WrappedPromise<T> {
-	promise.status = 'pending';
-	promise.then(
-		value => {
-			(promise as PartiallyWrappedPromise<T>).status = 'fulfilled';
-			(promise as any).value = value;
-		},
-		reason => {
-			(promise as PartiallyWrappedPromise<T>).status = 'rejected';
-			(promise as any).reason = reason;
-		}
-	);
-	return promise as WrappedPromise<T>;
-}
-
-export function getPromiseState(promise: PartiallyWrappedPromise<any>) {
-	return wrapPromise(promise).status;
-}
-
-export function isPromise<T>(value: any): value is Promise<T> {
-	return typeof value === 'object' && !!value && ('then' in value) && typeof value['then'] === 'function';
-}

package/src/lib/suspense.tsx

@@ -1,18 +0,0 @@
-import {Spinner} from "@wordpress/components";
-
-import {InspectorPanel} from "../controls";
-
-export * from "./suspense/promise-handlers";
-
-import {type ReactNode, Suspense, type SuspenseProps} from "react";
-
-type OptionallySuspensefulProps = Omit<SuspenseProps, 'children'>&{children: ReactNode|(() => ReactNode), hasSuspensefulOptions: (() => boolean)|boolean};
-export function OptionallySuspenseful({children: Children, hasSuspensefulOptions, ...props}: OptionallySuspensefulProps) {
-	if (typeof hasSuspensefulOptions === 'function' ? hasSuspensefulOptions() : hasSuspensefulOptions) {
-		return <Suspense fallback={<InspectorPanel opened initialOpen><Spinner/> Loading options</InspectorPanel>} {...props}>{
-			typeof Children === 'function' ? <Children/> : Children
-		}</Suspense>;
-	} else {
-		return typeof Children === 'function' ? <Children/> : Children;
-	}
-}

package/src/lib/useful-types.ts

@@ -1,82 +0,0 @@
-import type {Block, BlockSupports, BlockVariation} from "@wordpress/blocks";
-import type {FormTokenField} from '@wordpress/components';
-
-import type {ComponentProps} from "react";
-
-import type {PropertiesParameter} from "../blocks";
-
-export type TokenItem = Exclude<NonNullable<ComponentProps<typeof FormTokenField>['value']>[number], string>;
-export type WorkableUnknownAction = {type: "@@UNKNOWN_ACTION"};
-
-export type SubsequentArgsOfFunc<F> = F extends (arg: any, ...args: infer R) => any ? R : never;
-
-export type BlockName = `${string}/${string}`;
-export function isBlockName(str: string): str is BlockName {
-	const slashIndex = str.indexOf('/');
-	return slashIndex > 0 && slashIndex < str.length - 1;
-}
-
-export type ActualBEPAttrs = Record<string, any>&{className?: string|undefined};
-export type ActualBlockEditProps = {attributes: ActualBEPAttrs, setAttributes: (attributes: ActualBEPAttrs) => void, name: BlockName, clientId: string};
-export type ActualBlockListBlockProps = {
-	attributes: ActualBEPAttrs, name: BlockName, clientId: string, className?: string, style?: Record<string, unknown>, wrapperProps?: Record<string, unknown>,
-	isSelected: boolean, isValid: boolean, canMove: boolean, canRemove: boolean, isLocked: boolean
-};
-export type ActualBlockSaveProps = {[key: Exclude<string, 'className'|'style'>]: unknown|undefined, className?: string|undefined, style?: Record<string, unknown>};
-
-export type BlockJsonNativePropsConfig = {
-	type: "native",
-	properties?: PropertiesParameter|undefined
-};
-
-export type RegisterBlockAttrs<T extends Record<string, any> = {}> = {
-	name: BlockName, attributes: Block<T>['attributes'], usesContext?: string[],
-	plaudit?: "native"|boolean|{group: any}|BlockJsonNativePropsConfig|undefined,
-	supports: BlockSupports&Record<Exclude<string, keyof BlockSupports>, any>,
-	allowedBlocks?: BlockName[], ancestor?: BlockName[], parent?: BlockName[],
-	variations?: BlockVariation|BlockVariation[],
-};
-
-export function isBlockJsonNativePropsConfig(thing: unknown): thing is BlockJsonNativePropsConfig {
-	return typeof thing === 'object' && thing !== null && 'type' in thing && thing.type === "native";
-}
-
-export type NonEmptyArray<T> = [T, ...T[]];
-export function arrayIsNotEmpty<T>(arr: T[]|null|undefined): arr is NonEmptyArray<T> {
-	return !!arr && arr.length > 0;
-}
-export type PromisifyFunctionReturns<T extends {[K in string]: (...args: any[]) => any}> = {[K in keyof T]: (...args: Parameters<T[K]>) => Promise<ReturnType<T[K]>>};
-
-export type WPTaxonomyQuery = {
-	relation?: 'AND'|'OR',
-	clauses: Array<WPTaxonomyQuery>
-}|WPTaxonomyQueryFirstOrderClause;
-type WPTaxonomyQueryFirstOrderClause = {include_children?: boolean, operator?: 'AND'|'IN'|'NOT IN'|'EXISTS'|'NOT EXISTS'}&
-	(({taxonomy: string}&({terms: number|number[], field?: 'term_id'}|{terms: string|string[], field: 'slug'|'name'}))|{taxonomy?: string, terms: number|number[], field: 'term_taxonomy_id'});
-
-export type DbSource = {label: string, value: string, help?: string};
-
-export interface WP_Error {
-	code?: string|number;
-	message?: string;
-	data?: unknown;
-}
-export function is_wp_error(value: unknown): value is WP_Error {
-	if (typeof value !== 'object' || !value) {
-		return false;
-	}
-	let hasDefinedProperty = false;
-	if ('code' in value) {
-		if (value.code !== undefined && typeof value.code !== 'string' && typeof value.code !== 'number') {
-			return false;
-		}
-		hasDefinedProperty ||= value.code !== undefined;
-	}
-	if ('message' in value) {
-		if (value.message !== undefined && typeof value.message !== 'string') {
-			return false;
-		}
-		hasDefinedProperty ||= value.message !== undefined;
-	}
-	return hasDefinedProperty;
-}

package/src/schemas/README.md

@@ -1 +0,0 @@
-See `Deploy Schema` section of ../README.md