svelte-intlayer 8.2.3 → 8.2.4

package/dist/markdown/MarkdownProvider.svelte

@@ -12,7 +12,12 @@ export const preserveFrontmatter: boolean | undefined = undefined;
 export const tagfilter: boolean | undefined = undefined;
 
 let customRenderMarkdown:
-  | ((markdown: string, overrides?: any) => string)
+  | ((
+      markdown: string,
+      options?: any,
+      components?: HTMLComponents<'permissive', {}>,
+      wrapper?: any
+    ) => string)
   | undefined;
 export { customRenderMarkdown as renderMarkdown };
 
@@ -25,50 +30,47 @@ $: baseOptions = {
   tagfilter,
 };
 
-const internalRenderMarkdown = (markdown: string, overrides?: any) => {
+const internalRenderMarkdown = (
+  markdown: string,
+  options?: {
+    forceBlock?: boolean;
+    forceInline?: boolean;
+    preserveFrontmatter?: boolean;
+    tagfilter?: boolean;
+  },
+  componentsOverride?: HTMLComponents<'permissive', {}>,
+  wrapperOverride?: any
+) => {
   if (typeof customRenderMarkdown === 'function') {
-    return customRenderMarkdown(markdown, overrides);
+    return customRenderMarkdown(
+      markdown,
+      options,
+      componentsOverride,
+      wrapperOverride
+    );
   }
 
-  const isOptionsObject =
-    overrides &&
-    typeof overrides === 'object' &&
-    ('components' in overrides ||
-      'wrapper' in overrides ||
-      'forceBlock' in overrides ||
-      'forceInline' in overrides ||
-      'preserveFrontmatter' in overrides ||
-      'tagfilter' in overrides);
-
-  const {
-    components: overrideComponents,
-    wrapper: localWrapper,
-    forceBlock: localForceBlock,
-    forceInline: localForceInline,
-    preserveFrontmatter: localPreserveFrontmatter,
-    tagfilter: localTagfilter,
-    ...componentsFromRest
-  } = isOptionsObject ? overrides : { components: overrides };
-
-  const actualComponents = overrideComponents || componentsFromRest;
-
   const mergedOptions = {
-    forceBlock: localForceBlock ?? baseOptions.forceBlock,
-    forceInline: localForceInline ?? baseOptions.forceInline,
+    forceBlock: options?.forceBlock ?? baseOptions.forceBlock,
+    forceInline: options?.forceInline ?? baseOptions.forceInline,
     preserveFrontmatter:
-      localPreserveFrontmatter ?? baseOptions.preserveFrontmatter,
-    tagfilter: localTagfilter ?? baseOptions.tagfilter,
-    wrapper: localWrapper || baseOptions.wrapper,
+      options?.preserveFrontmatter ?? baseOptions.preserveFrontmatter,
+    tagfilter: options?.tagfilter ?? baseOptions.tagfilter,
+    wrapper: wrapperOverride || baseOptions.wrapper,
+    forceWrapper: !!(wrapperOverride || baseOptions.wrapper),
     components: {
       ...baseOptions.components,
-      ...actualComponents,
+      ...(componentsOverride ?? {}),
     },
   };
 
   return compileMarkdown(markdown, mergedOptions) as string;
 };
 
-setMarkdownContext({ renderMarkdown: internalRenderMarkdown });
+setMarkdownContext({
+  components,
+  renderMarkdown: internalRenderMarkdown,
+});
 </script>
 
 <slot />

package/dist/markdown/MarkdownProvider.svelte.d.ts

@@ -24,7 +24,7 @@ declare const MarkdownProvider: $$__sveltets_2_IsomorphicComponent<$$__sveltets_
     forceInline?: boolean | undefined;
     preserveFrontmatter?: boolean | undefined;
     tagfilter?: boolean | undefined;
-    renderMarkdown: ((markdown: string, overrides?: any) => string) | undefined;
+    renderMarkdown: ((markdown: string, options?: any, components?: HTMLComponents<"permissive", {}>, wrapper?: any) => string) | undefined;
 }, {
     default: {};
 }>, {

package/dist/markdown/MarkdownRenderer.svelte

@@ -13,14 +13,20 @@ export const tagfilter: boolean | undefined = undefined;
 
 const context = getMarkdownContext();
 
-$: htmlContent = context.renderMarkdown(value, {
-  components,
-  wrapper,
-  forceBlock,
-  forceInline,
-  preserveFrontmatter,
-  tagfilter,
-});
+$: htmlContent = context.renderMarkdown(
+  value,
+  {
+    forceBlock,
+    forceInline,
+    preserveFrontmatter,
+    tagfilter,
+  },
+  {
+    ...(context.components ?? {}),
+    ...(components ?? {}),
+  },
+  wrapper
+);
 </script>
 
 {@html htmlContent}

package/dist/markdown/context.d.ts

@@ -1,14 +1,18 @@
 import type { HTMLComponents } from '../html/types';
 export declare const MARKDOWN_CONTEXT_KEY: unique symbol;
-export type RenderMarkdownOptions = {
-    components?: HTMLComponents<'permissive', {}>;
-    wrapper?: any;
+export type MarkdownProviderOptions = {
     forceBlock?: boolean;
+    forceInline?: boolean;
     preserveFrontmatter?: boolean;
     tagfilter?: boolean;
 };
+export type RenderMarkdownOptions = MarkdownProviderOptions & {
+    components?: HTMLComponents<'permissive', {}>;
+    wrapper?: any;
+};
 export interface MarkdownContext {
-    renderMarkdown: (markdown: string, overrides?: HTMLComponents<'permissive', {}> | RenderMarkdownOptions) => string;
+    components?: HTMLComponents<'permissive', {}>;
+    renderMarkdown: (markdown: string, options?: MarkdownProviderOptions, components?: HTMLComponents<'permissive', {}>, wrapper?: any) => string;
 }
 export declare const getMarkdownContext: () => MarkdownContext;
 export declare const setMarkdownContext: (context: MarkdownContext) => void;

package/dist/markdown/context.js

@@ -3,7 +3,11 @@ import { compileMarkdown } from './compiler';
 export const MARKDOWN_CONTEXT_KEY = Symbol('INTLAYER_MARKDOWN_CONTEXT');
 export const getMarkdownContext = () => {
     return (getContext(MARKDOWN_CONTEXT_KEY) || {
-        renderMarkdown: (md, overrides) => compileMarkdown(md, overrides),
+        renderMarkdown: (md, _options, components, wrapper) => compileMarkdown(md, {
+            components,
+            wrapper,
+            forceWrapper: !!wrapper,
+        }),
     });
 };
 export const setMarkdownContext = (context) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-intlayer",
-  "version": "8.2.3",
+  "version": "8.2.4",
   "description": "Easily internationalize i18n your Svelte applications with type-safe multilingual content management.",
   "keywords": [
     "intlayer",