@wix/blog 1.0.691 → 1.0.692

package/build/cjs/context-tag-item-context-provider.d.ts

@@ -0,0 +1,185 @@
+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 `postTags` array — the object the platform hands the Tag Item context
+ * provider as its `tagData` prop. The `PostCategoryItem` twin, same contract rules:
+ * `_id`/`label` are the manifest contract (`TAG_ITEM_CONTRACT_ITEMS`, plain text and
+ * non-bindable), the remaining keys must match the Tag Item context manifest's `context.items`.
+ */
+interface PostTagItem {
+  /** 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;
+  itemTagLabel: RichText;
+  /** The tag's feed view; `undefined` (unlinked) without a resolvable base or slug. */
+  itemTagLink: Link | undefined;
+  /** Mirrors the Tag Item manifest's nested (non-bindable) `tagItem` data item. */
+  tagItem: {
+    label: string;
+    slug: string;
+  };
+}
+//#endregion
+//#region src/extensions/tag-item-context-provider/tag-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`).
+ *
+ * Nothing is derived per cell: a tag chip has no per-cell network read, so the item the platform
+ * injects is published unchanged (the object identity is the platform's, stable per cell render).
+ */
+type TagItemContextType = PostTagItem;
+/**
+ * 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 useTagItemContext(): TagItemContextType | null;
+/** Props accepted by {@link TagItemContextProvider}. */
+interface TagItemContextProviderProps extends React.PropsWithChildren {
+  /**
+   * The current item of the `postTags` 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 Category Item and
+   * Post Item providers; this provider has no standalone fetch path.
+   */
+  tagData?: PostTagItem;
+}
+/** Supplies one post tag, injected per repeater cell, to its children. */
+declare function TagItemContextProvider({
+  tagData,
+  children
+}: TagItemContextProviderProps): React.ReactNode;
+
+export { type PostTagItem, TagItemContextProvider, type TagItemContextProviderProps, type TagItemContextType, TagItemContextProvider as default, useTagItemContext };