@wix/blog 1.0.691 → 1.0.692

package/build/es/context-category-item-context-provider.d.mts

@@ -0,0 +1,189 @@
+import React from 'react';
+
+//#region ../../node_modules/type-fest/source/observable-like.d.ts
+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;
+  }
+}
+/**
+@remarks
+The TC39 observable proposal defines a `closed` property, but some implementations (such as xstream) do not as of 10/08/2021.
+As well, some guidance on making an `Observable` to not include `closed` property.
+@see https://github.com/tc39/proposal-observable/blob/master/src/Observable.js#L129-L130
+@see https://github.com/staltz/xstream/blob/6c22580c1d84d69773ee4b0905df44ad464955b3/src/index.ts#L79-L85
+@see https://github.com/benlesh/symbol-observable#making-an-object-observable
+
+@category Observable
+*/
+//#endregion
+//#region ../../node_modules/@wix/sdk-types/build/index.d.ts
+declare global {
+  interface ContextualClient {}
+}
+/**
+ * Creates concrete types from SDK descriptors when a contextual client is
+ * available.
+ *
+ * For a REST descriptor the built (bound) API is intersected with the original
+ * descriptor, matching what `contextualizeRESTModuleV2` returns at runtime — a
+ * value callable as the bound API and still usable as a descriptor. Keeping the
+ * descriptor half lets contextual modules be passed to descriptor-constrained
+ * helpers such as `elevate` from `@wix/sdk/context` (FEDINF-14092).
+ *
+ * The `& T` is scoped to REST descriptors — the only shape codegen wraps in
+ * `MaybeContext` — so `BuildDescriptors` (used by `createClient().use`) is left
+ * unchanged and stays bound-only. The fix lives here rather than in `elevate`,
+ * which is kept strict on purpose (see #941) so it still rejects bound-only
+ * functions that are unsafe through `createRESTModule`.
+ */
+declare global {
+  /**
+   * A global interface to set the exposure toggle for the SDK.
+   * @example
+   * ```ts
+   * declare global {
+   *  interface SDKExposureToggle {
+   *    alpha: true;
+   *  }
+   * }
+   */
+  interface SDKExposureToggle {}
+}
+declare global {
+  /**
+   * A global interface to set the type mode for the SDK.
+   * @example
+   * ```ts
+   * declare global {
+   *  interface SDKTypeMode {
+   *    strict: true;
+   *  }
+   * }
+   */
+  interface SDKTypeMode {}
+}
+//#endregion
+//#region ../../node_modules/@wix/editor-react-types/dist/links.d.ts
+type LinkTarget = '_self' | '_blank';
+/**
+ * A link to a URL, used for navigation within components.
+ *
+ * @example
+ * ```tsx
+ * import type { Link } from '@wix/editor-react-types';
+ *
+ * interface MyComponentProps {
+ *   link?: Link;
+ * }
+ * ```
+ */
+type Link = {
+  /**
+   * The link URL. For partial links (see `pageRole`), this is the router prefix
+   * (e.g. `https://www.my-site.com/prefix`) rather than a fully resolved URL.
+   */
+  href?: string;
+  /**
+   * Where this link should open.
+   * - `'_self'` — opens in the same page.
+   * - `'_blank'` — opens in a new tab.
+   */
+  target?: LinkTarget; /** The `rel` attribute of the link. Accepts LinkRel values separated by a space. */
+  rel?: string;
+  /**
+   * Page role identifier. Present only on partial links, where only the router prefix is
+   * known and the full URL format is owned by the Router/App. Applications can use such
+   * links in functions to resolve the complete URL at runtime (e.g. for binding links).
+   * Resolved links will not have this field.
+   */
+  pageRole?: string;
+};
+//#endregion
+//#region ../../node_modules/@wix/editor-react-types/dist/base.d.ts
+/**
+ * Rich text content with resolved links.
+ *
+ * @example
+ * ```tsx
+ * import type { RichText } from '@wix/editor-react-types';
+ *
+ * interface MyComponentProps {
+ *   description?: RichText;
+ * }
+ *
+ * const MyComponent = ({ description }: MyComponentProps) => (
+ *   <div>
+ *     {description?.html}
+ *     {description?.linkList.map((link) => (
+ *       <a key={link.href} href={link.href}>{link.href}</a>
+ *     ))}
+ *   </div>
+ * );
+ * ```
+ */
+type RichText = {
+  /** The original rich text content. */text: string; /** The HTML content with all links resolved. */
+  html: string; /** All links present in the rich text content. */
+  linkList: Array<Link>;
+};
+//#endregion
+//#region src/extensions/post-context-provider/utils.d.ts
+/**
+ * One item of the `postCategories` array — the object the platform hands the Category Item
+ * context provider as its `categoryData` prop (via the manifest's `contextImplementor`).
+ *
+ * `_id`/`label` are the manifest contract (`CATEGORY_ITEM_CONTRACT_ITEMS`, plain text and
+ * non-bindable); the remaining keys must match the Category Item context manifest's
+ * `context.items` keys, because the runtime resolves an element's binding by looking the
+ * key up on that provider's hook return value.
+ */
+interface PostCategoryItem {
+  /** Repeater item identity; also the manifest contract's `_id`. */
+  _id: string;
+  /** The manifest contract's `label` (plain text, non-bindable — see the richText label below). */
+  label: string;
+  itemCategoryLabel: RichText;
+  /** The category's feed view; `undefined` (unlinked) without a resolvable base or slug. */
+  itemCategoryLink: Link | undefined;
+  /** Mirrors the Category Item manifest's nested (non-bindable) `categoryItem` data item. */
+  categoryItem: {
+    label: string;
+    slug: string;
+  };
+}
+//#endregion
+//#region src/extensions/category-item-context-provider/category-item-context-provider.d.ts
+/**
+ * The context value IS the item — its keys sit top-level because the runtime resolves an
+ * element's binding by looking the manifest item key up on this hook's return value
+ * (through `contextSpecifier.hook`).
+ *
+ * Unlike the Post Item context there is nothing to derive per cell: a category chip has no
+ * per-cell network read, so the item the platform injects is published unchanged and no
+ * memo is needed (the object identity is the platform's, stable per cell render).
+ */
+type CategoryItemContextType = PostCategoryItem;
+/**
+ * Nullable rather than throwing: the hook runs for every element inside the repeater cell,
+ * including on the editor stage before the cell is populated.
+ */
+declare function useCategoryItemContext(): CategoryItemContextType | null;
+/** Props accepted by {@link CategoryItemContextProvider}. */
+interface CategoryItemContextProviderProps extends React.PropsWithChildren {
+  /**
+   * The current item of the `postCategories` array, injected by the platform per repeater
+   * cell (the Post context manifest's `contextImplementor.propKey`). Absent on the editor's
+   * unbound template cell — children then render over a null context, matching the Post
+   * Item provider; this provider has no standalone fetch path.
+   */
+  categoryData?: PostCategoryItem;
+}
+/** Supplies one post category, injected per repeater cell, to its children. */
+declare function CategoryItemContextProvider({
+  categoryData,
+  children
+}: CategoryItemContextProviderProps): React.ReactNode;
+
+export { CategoryItemContextProvider, type CategoryItemContextProviderProps, type CategoryItemContextType, type PostCategoryItem, CategoryItemContextProvider as default, useCategoryItemContext };