@mui/internal-core-docs 0.0.1 → 9.0.0-canary.1

package/branding/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./brandingTheme.js";
+export * from "./BrandingProvider.js";
+export * from "./BrandingCssVarsProvider.js";

package/branding/index.js

@@ -0,0 +1,3 @@
+export * from "./brandingTheme.js";
+export * from "./BrandingProvider.js";
+export * from "./BrandingCssVarsProvider.js";

package/codeStyling/codeStyling.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+export declare function CodeStylingProvider(props: {
+  children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useCodeStyling(): string;
+export declare function useNoSsrCodeStyling(): string | undefined;
+export declare function useSetCodeStyling(): React.Dispatch<React.SetStateAction<string>>;

package/codeStyling/codeStyling.js

@@ -0,0 +1,80 @@
+import * as React from 'react';
+import { CODE_STYLING } from "../constants/index.js";
+import { getCookie } from "../helpers/index.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+const CodeStylingContext = /*#__PURE__*/React.createContext({
+  codeStyling: CODE_STYLING.SYSTEM,
+  setCodeStyling: () => {}
+});
+if (process.env.NODE_ENV !== 'production') {
+  CodeStylingContext.displayName = 'CodeStyling';
+}
+function useFirstRender() {
+  const firstRenderRef = React.useRef(true);
+  React.useEffect(() => {
+    firstRenderRef.current = false;
+  }, []);
+  return firstRenderRef.current;
+}
+export function CodeStylingProvider(props) {
+  const {
+    children
+  } = props;
+  const [codeStyling, setCodeStyling] = React.useState(CODE_STYLING.SYSTEM);
+  const navigatedCodeStyling = React.useMemo(() => {
+    const navigatedCodeMatch = typeof window !== 'undefined' ? window.location.hash.match(/\.(js|tsx)$/) : null;
+    if (navigatedCodeMatch === null) {
+      return undefined;
+    }
+    if (typeof window !== 'undefined') {
+      if (window.location.hash.includes('tailwind-')) {
+        return CODE_STYLING.TAILWIND;
+      }
+      if (window.location.hash.includes('css-')) {
+        return CODE_STYLING.CSS;
+      }
+      if (window.location.hash.includes('system-')) {
+        return CODE_STYLING.SYSTEM;
+      }
+    }
+    return undefined;
+  }, []);
+  const persistedCodeStyling = React.useMemo(() => {
+    if (typeof window === 'undefined') {
+      return undefined;
+    }
+    return getCookie('codeStyling');
+  }, []);
+  const isFirstRender = useFirstRender();
+
+  // We initialize from navigation or cookies. on subsequent renders the store is the truth
+  const noSsrCodeStyling = isFirstRender === true ? navigatedCodeStyling || persistedCodeStyling || codeStyling : codeStyling;
+  React.useEffect(() => {
+    if (codeStyling !== noSsrCodeStyling) {
+      setCodeStyling(noSsrCodeStyling);
+    }
+  }, [codeStyling, noSsrCodeStyling]);
+  React.useEffect(() => {
+    document.cookie = `codeStyling=${codeStyling};path=/;max-age=31536000`;
+  }, [codeStyling]);
+  const contextValue = React.useMemo(() => {
+    return {
+      codeStyling,
+      noSsrCodeStyling,
+      setCodeStyling
+    };
+  }, [codeStyling, noSsrCodeStyling]);
+  return /*#__PURE__*/_jsx(CodeStylingContext.Provider, {
+    value: contextValue,
+    children: children
+  });
+}
+export function useCodeStyling() {
+  return React.useContext(CodeStylingContext).codeStyling;
+}
+export function useNoSsrCodeStyling() {
+  return React.useContext(CodeStylingContext).noSsrCodeStyling;
+}
+export function useSetCodeStyling() {
+  return React.useContext(CodeStylingContext).setCodeStyling;
+}

package/codeStyling/index.d.ts

@@ -0,0 +1 @@
+export { CodeStylingProvider, useCodeStyling, useNoSsrCodeStyling, useSetCodeStyling } from "./codeStyling.js";

package/codeStyling/index.js

@@ -0,0 +1 @@
+export { CodeStylingProvider, useCodeStyling, useNoSsrCodeStyling, useSetCodeStyling } from "./codeStyling.js";

package/codeVariant/codeVariant.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+export declare function CodeVariantProvider(props: {
+  children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useCodeVariant(): string;
+export declare function useNoSsrCodeVariant(): string | undefined;
+export declare function useSetCodeVariant(): React.Dispatch<React.SetStateAction<string>>;

package/codeVariant/codeVariant.js

@@ -0,0 +1,69 @@
+import * as React from 'react';
+import { CODE_VARIANTS } from "../constants/index.js";
+import { getCookie } from "../helpers/index.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+const CodeVariantContext = /*#__PURE__*/React.createContext({
+  codeVariant: CODE_VARIANTS.TS,
+  setCodeVariant: () => {}
+});
+if (process.env.NODE_ENV !== 'production') {
+  CodeVariantContext.displayName = 'CodeVariant';
+}
+function useFirstRender() {
+  const firstRenderRef = React.useRef(true);
+  React.useEffect(() => {
+    firstRenderRef.current = false;
+  }, []);
+  return firstRenderRef.current;
+}
+export function CodeVariantProvider(props) {
+  const {
+    children
+  } = props;
+  const [codeVariant, setCodeVariant] = React.useState(CODE_VARIANTS.TS);
+  const navigatedCodeVariant = React.useMemo(() => {
+    const navigatedCodeVariantMatch = typeof window !== 'undefined' ? window.location.hash.match(/\.(js|tsx)$/) : null;
+    if (navigatedCodeVariantMatch === null) {
+      return undefined;
+    }
+    return navigatedCodeVariantMatch[1] === 'tsx' ? CODE_VARIANTS.TS : CODE_VARIANTS.JS;
+  }, []);
+  const persistedCodeVariant = React.useMemo(() => {
+    if (typeof window === 'undefined') {
+      return undefined;
+    }
+    return getCookie('codeVariant');
+  }, []);
+  const isFirstRender = useFirstRender();
+
+  // We initialize from navigation or cookies. on subsequent renders the store is the truth
+  const noSsrCodeVariant = isFirstRender === true ? navigatedCodeVariant || persistedCodeVariant || codeVariant : codeVariant;
+  React.useEffect(() => {
+    if (codeVariant !== noSsrCodeVariant) {
+      setCodeVariant(noSsrCodeVariant);
+    }
+  }, [codeVariant, noSsrCodeVariant]);
+  React.useEffect(() => {
+    document.cookie = `codeVariant=${codeVariant};path=/;max-age=31536000`;
+  }, [codeVariant]);
+  const contextValue = React.useMemo(() => {
+    return {
+      codeVariant,
+      noSsrCodeVariant,
+      setCodeVariant
+    };
+  }, [codeVariant, noSsrCodeVariant]);
+  return /*#__PURE__*/_jsx(CodeVariantContext.Provider, {
+    value: contextValue,
+    children: children
+  });
+}
+export function useCodeVariant() {
+  return React.useContext(CodeVariantContext).codeVariant;
+}
+export function useNoSsrCodeVariant() {
+  return React.useContext(CodeVariantContext).noSsrCodeVariant;
+}
+export function useSetCodeVariant() {
+  return React.useContext(CodeVariantContext).setCodeVariant;
+}

package/codeVariant/index.d.ts

@@ -0,0 +1 @@
+export { CodeVariantProvider, useCodeVariant, useNoSsrCodeVariant, useSetCodeVariant } from "./codeVariant.js";

package/codeVariant/index.js

@@ -0,0 +1 @@
+export { CodeVariantProvider, useCodeVariant, useNoSsrCodeVariant, useSetCodeVariant } from "./codeVariant.js";

package/constants/constants.d.ts

@@ -0,0 +1,13 @@
+export declare const CODE_VARIANTS: {
+  JS: string;
+  TS: string;
+};
+export declare const CODE_STYLING: {
+  SYSTEM: string;
+  TAILWIND: string;
+  CSS: string;
+};
+export declare const LANGUAGES_LABEL: {
+  code: string;
+  text: string;
+}[];

package/constants/constants.js

@@ -0,0 +1,15 @@
+export const CODE_VARIANTS = {
+  JS: 'JS',
+  TS: 'TS'
+};
+export const CODE_STYLING = {
+  SYSTEM: 'MUI System',
+  TAILWIND: 'Tailwind',
+  CSS: 'CSS'
+};
+
+// Valid languages to use in production
+export const LANGUAGES_LABEL = [{
+  code: 'en',
+  text: 'English'
+}];

package/constants/index.d.ts

@@ -0,0 +1 @@
+export * from "./constants.js";

package/constants/index.js

@@ -0,0 +1 @@
+export * from "./constants.js";

package/findActivePage/findActivePage.d.ts

@@ -0,0 +1,5 @@
+import type { MuiPage } from "../MuiPage/index.js";
+export default function findActivePage(currentPages: MuiPage[], currentPathname: string): {
+  activePage: MuiPage | null;
+  activePageParents: MuiPage[];
+};

package/findActivePage/findActivePage.js

@@ -0,0 +1,35 @@
+export default function findActivePage(currentPages, currentPathname) {
+  const map = {};
+  const mapParent = {};
+  const pathname = currentPathname.replace('/[docsTab]', '').replace('components-api', '').replace('hooks-api', '');
+  const traverse = parent => {
+    (parent.children || []).forEach(child => {
+      const childPathname = child.pathname.replace('/[docsTab]', '').replace('components-api', '').replace('hooks-api', '');
+      map[childPathname] = child;
+      const isChildApiPathname = child.pathname.includes('components-api') || child.pathname.includes('hooks-api');
+      if (!isChildApiPathname && mapParent[childPathname]) {
+        throw new Error(`Duplicated pathname ${child.pathname} in pages`);
+      }
+      if (!isChildApiPathname) {
+        mapParent[childPathname] = parent;
+      }
+      traverse(child);
+    });
+  };
+  traverse({
+    pathname: '/',
+    children: currentPages
+  });
+  const activePage = map[pathname] || null;
+  const activePageParents = [];
+  let traversePage = activePage;
+  while (traversePage && traversePage.pathname !== '/') {
+    const parent = mapParent[traversePage.pathname];
+    activePageParents.push(parent);
+    traversePage = parent;
+  }
+  return {
+    activePage,
+    activePageParents
+  };
+}

package/findActivePage/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./findActivePage.js";

package/findActivePage/index.js

@@ -0,0 +1 @@
+export { default } from "./findActivePage.js";

package/getProductInfoFromUrl/getProductInfoFromUrl.d.ts

@@ -0,0 +1,8 @@
+export type MuiProductId = 'null' | 'base-ui' | 'material-ui' | 'system' | 'docs-infra' | 'docs' | 'x-data-grid' | 'x-date-pickers' | 'x-charts' | 'x-tree-view' | 'toolpad-studio' | 'toolpad-core';
+type MuiProductCategoryId = 'null' | 'core' | 'x';
+interface MuiProductInfo {
+  productId: MuiProductId;
+  productCategoryId: MuiProductCategoryId;
+}
+export default function getProductInfoFromUrl(asPath: string): MuiProductInfo;
+export {};

package/getProductInfoFromUrl/getProductInfoFromUrl.js

@@ -0,0 +1,50 @@
+import { pathnameToLanguage } from "../helpers/helpers.js";
+// This is a fallback logic to define the productId and productCategoryId of the page.
+// Markdown pages can override this value when the URL patterns they follow are a bit strange,
+// which should stay the rare exception.
+export default function getProductInfoFromUrl(asPath) {
+  const asPathWithoutLang = pathnameToLanguage(asPath).canonicalAsServer;
+  const firstFolder = asPathWithoutLang.replace(/^\/+([^/]+)\/.*/, '$1');
+
+  // When serialized undefined/null are the same, so we encode null as 'null' to be
+  // able to differentiate when the value isn't set vs. set to the right null value.
+  let productCategoryId = 'null';
+  let productId = 'null';
+  if (firstFolder === 'material-ui' || firstFolder === 'joy-ui' || firstFolder === 'base-ui' || firstFolder === 'system') {
+    productCategoryId = 'core';
+    productId = firstFolder;
+  }
+  if (firstFolder === 'x') {
+    productCategoryId = 'x';
+    productId = `x-${asPathWithoutLang.replace('/x/react-', '').replace(/\/.*/, '')}`;
+
+    // No match, give up on it.
+    if (productId === 'x-') {
+      productId = 'null';
+    }
+  }
+  if (firstFolder === 'toolpad') {
+    productCategoryId = 'toolpad';
+    const secondFolder = asPathWithoutLang.replace(/^\/+[^/]+\/([^/]+)\/.*/, '$1');
+    if (secondFolder === 'studio') {
+      productId = 'toolpad-studio';
+    } else {
+      productId = 'toolpad-core';
+    }
+  }
+  if (firstFolder === 'docs') {
+    productId = firstFolder;
+  }
+
+  // TODO remove, legacy
+  if (firstFolder === 'versions' || firstFolder === 'production-error') {
+    productId = 'docs';
+  }
+  if (asPathWithoutLang.startsWith('/experiments/docs/')) {
+    productId = 'docs-infra';
+  }
+  return {
+    productCategoryId,
+    productId
+  };
+}

package/getProductInfoFromUrl/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./getProductInfoFromUrl.js";
+export type { MuiProductId } from "./getProductInfoFromUrl.js";

package/getProductInfoFromUrl/index.js

@@ -0,0 +1 @@
+export { default } from "./getProductInfoFromUrl.js";

package/globalSelector/globalSelector.d.ts

@@ -0,0 +1,2 @@
+import { Element } from 'stylis';
+export default function globalSelector(element: Element): void;

package/globalSelector/globalSelector.js

@@ -0,0 +1,17 @@
+/* eslint-disable default-case */
+import { RULESET } from 'stylis';
+
+// A workaround to https://github.com/emotion-js/emotion/issues/2836
+// to be able to use `:where` selector for styling.
+export default function globalSelector(element) {
+  switch (element.type) {
+    case RULESET:
+      element.props = element.props.map(value => {
+        if (value.match(/(:where|:is)\(/)) {
+          value = value.replace(/\.[^:]+(:where|:is)/, '$1');
+          return value;
+        }
+        return value;
+      });
+  }
+}

package/globalSelector/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./globalSelector.js";

package/globalSelector/index.js

@@ -0,0 +1 @@
+export { default } from "./globalSelector.js";

package/helpers/helpers.d.ts

@@ -0,0 +1,31 @@
+import type { Translate } from "../i18n/index.js";
+export declare function pascalCase(str: string): string;
+export interface Page {
+  pathname: string;
+  query?: object;
+  subheader?: string;
+  title?: string | false;
+}
+export declare function pageToTitle(page: Page): string | null;
+export declare function pageToTitleI18n(page: Page, t: Translate): string | null;
+/**
+ * Get the value of a cookie
+ * Source: https://vanillajstoolkit.com/helpers/getcookie/
+ * @param name - The name of the cookie
+ * @return The cookie value
+ */
+export declare function getCookie(name: string): string | undefined;
+/**
+ * as is a reference to Next.js's as, the path in the URL
+ * pathname is a reference to Next.js's pathname, the name of page in the filesystem
+ * https://nextjs.org/docs/api-reference/next/router
+ *
+ * @param pathname - The URL pathname
+ * @param languages - List of supported language codes. Defaults to `['en']`.
+ */
+export declare function pathnameToLanguage(pathname: string, languages?: string[]): {
+  userLanguage: string;
+  canonicalAs: string;
+  canonicalAsServer: string;
+  canonicalPathname: string;
+};

package/helpers/helpers.js

@@ -0,0 +1,87 @@
+import { camelCase, upperFirst } from 'es-toolkit/string';
+export function pascalCase(str) {
+  return upperFirst(camelCase(str));
+}
+function titleize(hyphenedString) {
+  return upperFirst(hyphenedString.split('-').join(' '));
+}
+export function pageToTitle(page) {
+  if (page.title === false) {
+    return null;
+  }
+  if (page.title) {
+    return page.title;
+  }
+  const path = page.subheader || page.pathname;
+  const name = path.replace(/.*\//, '').replace('react-', '').replace(/\..*/, '');
+
+  // TODO remove post migration
+  if (path.includes('/api-docs/')) {
+    return pascalCase(name);
+  }
+
+  // TODO support more than React component API (PascalCase)
+  if (path.includes('/api/')) {
+    return name.startsWith('use') ? camelCase(name) : pascalCase(name);
+  }
+  return titleize(name);
+}
+export function pageToTitleI18n(page, t) {
+  const path = page.subheader || page.pathname;
+  return page.query ? pageToTitle(page) : t(`pages.${path}`, {
+    ignoreWarning: true
+  }) || pageToTitle(page);
+}
+
+/**
+ * Get the value of a cookie
+ * Source: https://vanillajstoolkit.com/helpers/getcookie/
+ * @param name - The name of the cookie
+ * @return The cookie value
+ */
+export function getCookie(name) {
+  if (typeof document === 'undefined') {
+    throw new Error('getCookie() is not supported on the server. Fallback to a different value when rendering on the server.');
+  }
+  const value = `; ${document.cookie}`;
+  const parts = value.split(`; ${name}=`);
+  if (parts.length === 2) {
+    return parts[1].split(';').shift();
+  }
+  return undefined;
+}
+
+/**
+ * as is a reference to Next.js's as, the path in the URL
+ * pathname is a reference to Next.js's pathname, the name of page in the filesystem
+ * https://nextjs.org/docs/api-reference/next/router
+ *
+ * @param pathname - The URL pathname
+ * @param languages - List of supported language codes. Defaults to `['en']`.
+ */
+export function pathnameToLanguage(pathname, languages = ['en']) {
+  let userLanguage;
+  const userLanguageCandidate = pathname.substring(1, 3);
+  if ([...languages, 'zh'].includes(userLanguageCandidate) && pathname.startsWith(`/${userLanguageCandidate}/`)) {
+    userLanguage = userLanguageCandidate;
+  } else {
+    userLanguage = 'en';
+  }
+  const canonicalAs = userLanguage === 'en' ? pathname : pathname.substring(3);
+  // Remove hash as it's never sent to the server
+  // https://github.com/vercel/next.js/issues/25202
+  const canonicalAsServer = canonicalAs.replace(/#(.*)$/, '');
+  let canonicalPathname = canonicalAsServer.replace(/^\/api/, '/api-docs');
+
+  // Remove trailing slash as Next.js doesn't expect it here
+  // https://nextjs.org/docs/pages/api-reference/functions/use-router#router-object
+  if (canonicalPathname !== '/') {
+    canonicalPathname = canonicalPathname.replace(/\/$/, '');
+  }
+  return {
+    userLanguage,
+    canonicalAs,
+    canonicalAsServer,
+    canonicalPathname
+  };
+}

package/helpers/index.d.ts

@@ -0,0 +1,2 @@
+export { pascalCase, pageToTitle, pageToTitleI18n, getCookie, pathnameToLanguage } from "./helpers.js";
+export type { Page } from "./helpers.js";

package/helpers/index.js

@@ -0,0 +1 @@
+export { pascalCase, pageToTitle, pageToTitleI18n, getCookie, pathnameToLanguage } from "./helpers.js";

package/i18n/i18n.d.ts

@@ -0,0 +1,27 @@
+import * as React from 'react';
+import PropTypes from 'prop-types';
+export interface UserLanguageProviderProps {
+  children: React.ReactNode;
+  translations?: Translations;
+  defaultUserLanguage: string;
+}
+export declare function UserLanguageProvider(props: UserLanguageProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace UserLanguageProvider {
+  var propTypes: {
+    children: PropTypes.Validator<NonNullable<PropTypes.ReactNodeLike>>;
+    defaultUserLanguage: PropTypes.Requireable<string>;
+  };
+}
+export declare function useUserLanguage(): string;
+export declare function useSetUserLanguage(): React.Dispatch<React.SetStateAction<string>>;
+export interface TranslateOptions {
+  ignoreWarning?: boolean;
+}
+export type Translate = (key: string, options?: TranslateOptions) => any;
+export declare function useTranslate(): Translate;
+export type Translations = { [key in string]?: string | Translations };
+export interface RequireContext {
+  (req: string): string;
+  keys: () => string[];
+}
+export declare function mapTranslations(req: RequireContext): Translations;

package/i18n/i18n.js

@@ -0,0 +1,111 @@
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import deepmerge from '@mui/utils/deepmerge';
+import defaultTranslations from "../translations/index.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+const TranslationsContext = /*#__PURE__*/React.createContext(defaultTranslations);
+function TranslationsProvider({
+  translations = {},
+  children
+}) {
+  const currentTranslations = React.useContext(TranslationsContext);
+  const mergedTranslations = React.useMemo(() => deepmerge(currentTranslations, translations), [currentTranslations, translations]);
+  return /*#__PURE__*/_jsx(TranslationsContext.Provider, {
+    value: mergedTranslations,
+    children: children
+  });
+}
+function getPath(obj, path) {
+  if (!path || typeof path !== 'string') {
+    return null;
+  }
+  const translation = path.split('.').reduce((acc, item) => acc && typeof acc === 'object' && acc[item] || null, obj);
+  if (typeof translation === 'object') {
+    return null;
+  }
+  return translation;
+}
+const UserLanguageContext = /*#__PURE__*/React.createContext({
+  userLanguage: '',
+  setUserLanguage: () => {}
+});
+if (process.env.NODE_ENV !== 'production') {
+  UserLanguageContext.displayName = 'UserLanguage';
+}
+export function UserLanguageProvider(props) {
+  const {
+    children,
+    translations,
+    defaultUserLanguage
+  } = props;
+  const [userLanguage, setUserLanguage] = React.useState(defaultUserLanguage);
+  const contextValue = React.useMemo(() => {
+    return {
+      userLanguage,
+      setUserLanguage
+    };
+  }, [userLanguage]);
+  return /*#__PURE__*/_jsx(TranslationsProvider, {
+    translations: translations,
+    children: /*#__PURE__*/_jsx(UserLanguageContext.Provider, {
+      value: contextValue,
+      children: children
+    })
+  });
+}
+process.env.NODE_ENV !== "production" ? UserLanguageProvider.propTypes = {
+  children: PropTypes.node.isRequired,
+  defaultUserLanguage: PropTypes.string
+} : void 0;
+export function useUserLanguage() {
+  return React.useContext(UserLanguageContext).userLanguage;
+}
+export function useSetUserLanguage() {
+  return React.useContext(UserLanguageContext).setUserLanguage;
+}
+const warnedOnce = {};
+
+// TODO, migrate to use warnOnce() helper
+const warn = (userLanguage, key, ignoreWarning) => {
+  const fullKey = `${userLanguage}:${key}`;
+  // No warnings in CI env
+  if (!ignoreWarning && !warnedOnce[fullKey] && typeof window !== 'undefined') {
+    console.warn(`Missing translation for ${fullKey}`);
+    warnedOnce[fullKey] = true;
+  }
+};
+export function useTranslate() {
+  const userLanguage = useUserLanguage();
+  const translations = React.useContext(TranslationsContext);
+  return React.useMemo(() => function translate(key, options = {}) {
+    const {
+      ignoreWarning = false
+    } = options;
+    const wordings = translations[userLanguage];
+    if (!wordings) {
+      console.error(`Missing language: ${userLanguage}.`);
+      return '…';
+    }
+    const translation = getPath(wordings, key);
+    if (!translation) {
+      if (process.env.NODE_ENV !== 'production') {
+        warn(userLanguage, key, ignoreWarning);
+      }
+      const enTranslation = getPath(translations.en, key);
+      return enTranslation ?? null;
+    }
+    return translation;
+  }, [userLanguage, translations]);
+}
+export function mapTranslations(req) {
+  const result = {};
+  req.keys().forEach(filename => {
+    const match = filename.match(/-([a-z]{2}).json$/);
+    if (match) {
+      result[match[1]] = req(filename);
+    } else {
+      result.en = req(filename);
+    }
+  });
+  return result;
+}

package/i18n/index.d.ts

@@ -0,0 +1 @@
+export * from "./i18n.js";

package/i18n/index.js

@@ -0,0 +1 @@
+export * from "./i18n.js";

package/mapApiPageTranslations/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./mapApiPageTranslations.js";

package/mapApiPageTranslations/index.js

@@ -0,0 +1 @@
+export { default } from "./mapApiPageTranslations.js";