2023-01-27 14:08:30 +00:00
|
|
|
import LoginPageSvgUrl from "PUBLIC_DIR/images/logo/loginpage.svg?url";
|
|
|
|
import DarkLoginPageSvgUrl from "PUBLIC_DIR/images/logo/dark_loginpage.svg?url";
|
|
|
|
import LeftMenuSvgUrl from "PUBLIC_DIR/images/logo/leftmenu.svg?url";
|
|
|
|
import DocseditorSvgUrl from "PUBLIC_DIR/images/logo/docseditor.svg?url";
|
|
|
|
import LightSmallSvgUrl from "PUBLIC_DIR/images/logo/lightsmall.svg?url";
|
|
|
|
import DocsEditoRembedSvgUrl from "PUBLIC_DIR/images/logo/docseditorembed.svg?url";
|
|
|
|
import DarkLightSmallSvgUrl from "PUBLIC_DIR/images/logo/dark_lightsmall.svg?url";
|
|
|
|
import FaviconIco from "PUBLIC_DIR/favicon.ico";
|
2022-12-27 14:04:56 +00:00
|
|
|
|
2023-01-27 14:08:30 +00:00
|
|
|
import BackgroundPatternReactSvgUrl from "PUBLIC_DIR/images/background.pattern.react.svg?url";
|
|
|
|
import BackgroundPatternOrangeReactSvgUrl from "PUBLIC_DIR/images/background.pattern.orange.react.svg?url";
|
|
|
|
import BackgroundPatternGreenReactSvgUrl from "PUBLIC_DIR/images/background.pattern.green.react.svg?url";
|
|
|
|
import BackgroundPatternRedReactSvgUrl from "PUBLIC_DIR/images/background.pattern.red.react.svg?url";
|
|
|
|
import BackgroundPatternPurpleReactSvgUrl from "PUBLIC_DIR/images/background.pattern.purple.react.svg?url";
|
|
|
|
import BackgroundPatternLightBlueReactSvgUrl from "PUBLIC_DIR/images/background.pattern.lightBlue.react.svg?url";
|
|
|
|
import BackgroundPatternBlackReactSvgUrl from "PUBLIC_DIR/images/background.pattern.black.react.svg?url";
|
2022-12-29 09:26:20 +00:00
|
|
|
|
2023-04-07 14:23:34 +00:00
|
|
|
import moment from "moment";
|
|
|
|
|
2023-08-21 12:48:28 +00:00
|
|
|
import { LANGUAGE, ThemeKeys, RtlLanguages } from "../constants";
|
2020-09-30 08:43:19 +00:00
|
|
|
import sjcl from "sjcl";
|
2020-10-13 12:51:14 +00:00
|
|
|
import { isMobile } from "react-device-detect";
|
2022-07-22 19:01:25 +00:00
|
|
|
import TopLoaderService from "@docspace/components/top-loading-indicator";
|
2022-07-08 15:30:50 +00:00
|
|
|
import { Encoder } from "./encoder";
|
2022-08-17 07:23:46 +00:00
|
|
|
import FilesFilter from "../api/files/filter";
|
2022-12-23 15:54:04 +00:00
|
|
|
import combineUrlFunc from "./combineUrl";
|
2023-10-12 15:25:55 +00:00
|
|
|
|
2023-11-01 09:29:49 +00:00
|
|
|
import { getCookie } from "@docspace/components/utils/cookie";
|
2023-01-31 09:18:19 +00:00
|
|
|
// import { translations } from "./i18next-http-backend/lib/translations";
|
2019-11-19 12:35:56 +00:00
|
|
|
export const toUrlParams = (obj, skipNull) => {
|
|
|
|
let str = "";
|
|
|
|
for (var key in obj) {
|
2021-04-15 07:27:23 +00:00
|
|
|
if (skipNull && !obj[key]) continue;
|
2019-11-19 12:35:56 +00:00
|
|
|
|
|
|
|
if (str !== "") {
|
|
|
|
str += "&";
|
|
|
|
}
|
|
|
|
|
2023-07-12 11:36:09 +00:00
|
|
|
// added for double employeetype
|
2023-08-09 10:44:19 +00:00
|
|
|
if (Array.isArray(obj[key]) && key === "employeetypes") {
|
2023-07-12 11:36:09 +00:00
|
|
|
for (let i = 0; i < obj[key].length; i++) {
|
|
|
|
str += key + "=" + encodeURIComponent(obj[key][i]);
|
|
|
|
if (i !== obj[key].length - 1) {
|
|
|
|
str += "&";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (typeof obj[key] === "object") {
|
2022-07-08 07:40:04 +00:00
|
|
|
str += key + "=" + encodeURIComponent(JSON.stringify(obj[key]));
|
2022-07-05 07:03:12 +00:00
|
|
|
} else {
|
|
|
|
str += key + "=" + encodeURIComponent(obj[key]);
|
|
|
|
}
|
2019-11-19 12:35:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return str;
|
2020-09-19 15:24:48 +00:00
|
|
|
};
|
2019-11-19 12:35:56 +00:00
|
|
|
|
2022-07-08 15:29:50 +00:00
|
|
|
export const decodeDisplayName = (items) => {
|
2022-07-08 15:20:25 +00:00
|
|
|
return items.map((item) => {
|
|
|
|
if (!item) return item;
|
|
|
|
|
|
|
|
if (item.updatedBy?.displayName) {
|
|
|
|
item.updatedBy.displayName = Encoder.htmlDecode(
|
|
|
|
item.updatedBy.displayName
|
|
|
|
);
|
|
|
|
}
|
|
|
|
if (item.createdBy?.displayName) {
|
|
|
|
item.createdBy.displayName = Encoder.htmlDecode(
|
|
|
|
item.createdBy.displayName
|
|
|
|
);
|
|
|
|
}
|
|
|
|
return item;
|
|
|
|
});
|
|
|
|
};
|
|
|
|
|
2019-11-19 12:35:56 +00:00
|
|
|
export function getObjectByLocation(location) {
|
|
|
|
if (!location.search || !location.search.length) return null;
|
|
|
|
|
|
|
|
const searchUrl = location.search.substring(1);
|
2021-11-11 12:37:23 +00:00
|
|
|
const decodedString = decodeURIComponent(searchUrl)
|
2022-07-08 07:40:04 +00:00
|
|
|
.replace(/\["/g, '["')
|
|
|
|
.replace(/"\]/g, '"]')
|
2021-11-11 12:37:23 +00:00
|
|
|
.replace(/"/g, '\\"')
|
|
|
|
.replace(/&/g, '","')
|
|
|
|
.replace(/=/g, '":"')
|
2022-07-08 07:40:04 +00:00
|
|
|
.replace(/\\/g, "\\\\")
|
|
|
|
.replace(/\[\\\\"/g, '["')
|
|
|
|
.replace(/\\\\"\]/g, '"]')
|
|
|
|
.replace(/"\[/g, "[")
|
|
|
|
.replace(/\]"/g, "]")
|
2023-08-22 08:47:46 +00:00
|
|
|
.replace(/\\\\",\\\\"/g, '","')
|
|
|
|
.replace(/\\\\\\\\"/g, '\\"');
|
2022-07-08 07:40:04 +00:00
|
|
|
|
2023-08-22 08:47:46 +00:00
|
|
|
try {
|
|
|
|
const object = JSON.parse(`{"${decodedString}"}`);
|
|
|
|
return object;
|
|
|
|
} catch (e) {
|
|
|
|
return {};
|
|
|
|
}
|
2019-11-19 12:35:56 +00:00
|
|
|
}
|
2020-01-21 05:56:04 +00:00
|
|
|
|
2022-08-05 14:21:14 +00:00
|
|
|
export function changeLanguage(i18n, currentLng = getCookie(LANGUAGE)) {
|
2020-09-19 15:24:48 +00:00
|
|
|
return currentLng
|
|
|
|
? i18n.language !== currentLng
|
|
|
|
? i18n.changeLanguage(currentLng)
|
|
|
|
: Promise.resolve((...args) => i18n.t(...args))
|
|
|
|
: i18n.changeLanguage("en");
|
2020-01-21 05:56:04 +00:00
|
|
|
}
|
2020-09-18 08:12:09 +00:00
|
|
|
|
2020-09-30 21:44:49 +00:00
|
|
|
export function createPasswordHash(password, hashSettings) {
|
2020-10-01 16:04:10 +00:00
|
|
|
if (
|
|
|
|
!password ||
|
|
|
|
!hashSettings ||
|
|
|
|
typeof password !== "string" ||
|
|
|
|
typeof hashSettings !== "object" ||
|
|
|
|
!hashSettings.hasOwnProperty("salt") ||
|
|
|
|
!hashSettings.hasOwnProperty("size") ||
|
|
|
|
!hashSettings.hasOwnProperty("iterations") ||
|
|
|
|
typeof hashSettings.size !== "number" ||
|
|
|
|
typeof hashSettings.iterations !== "number" ||
|
|
|
|
typeof hashSettings.salt !== "string"
|
|
|
|
)
|
|
|
|
throw new Error("Invalid params.");
|
|
|
|
|
2020-09-30 21:44:49 +00:00
|
|
|
const { size, iterations, salt } = hashSettings;
|
2020-09-30 08:43:19 +00:00
|
|
|
|
|
|
|
let bits = sjcl.misc.pbkdf2(password, salt, iterations);
|
|
|
|
bits = bits.slice(0, size / 32);
|
|
|
|
const hash = sjcl.codec.hex.fromBits(bits);
|
|
|
|
|
|
|
|
return hash;
|
2020-01-21 05:56:04 +00:00
|
|
|
}
|
2020-10-05 12:37:09 +00:00
|
|
|
|
2020-12-07 08:11:04 +00:00
|
|
|
export function updateTempContent(isAuth = false) {
|
|
|
|
if (isAuth) {
|
2021-02-03 12:42:47 +00:00
|
|
|
const el = document.getElementById("burger-loader-svg");
|
|
|
|
if (el) {
|
|
|
|
el.style.display = "block";
|
|
|
|
}
|
|
|
|
|
|
|
|
const el1 = document.getElementById("logo-loader-svg");
|
|
|
|
if (el1) {
|
|
|
|
el1.style.display = "block";
|
|
|
|
}
|
2020-12-07 08:11:04 +00:00
|
|
|
|
2021-02-03 12:42:47 +00:00
|
|
|
const el2 = document.getElementById("avatar-loader-svg");
|
|
|
|
if (el2) {
|
|
|
|
el2.style.display = "block";
|
|
|
|
}
|
2020-12-07 08:11:04 +00:00
|
|
|
} else {
|
|
|
|
const tempElm = document.getElementById("temp-content");
|
|
|
|
if (tempElm) {
|
|
|
|
tempElm.outerHTML = "";
|
|
|
|
}
|
2020-09-23 15:42:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-06-11 14:29:29 +00:00
|
|
|
let timer = null;
|
|
|
|
|
2020-09-23 15:42:47 +00:00
|
|
|
export function hideLoader() {
|
2020-10-13 12:51:14 +00:00
|
|
|
if (isMobile) return;
|
2021-06-11 14:29:29 +00:00
|
|
|
if (timer) {
|
|
|
|
clearTimeout(timer);
|
|
|
|
timer = null;
|
|
|
|
}
|
2021-03-04 11:36:31 +00:00
|
|
|
TopLoaderService.end();
|
2020-09-23 15:42:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
export function showLoader() {
|
2020-10-13 12:51:14 +00:00
|
|
|
if (isMobile) return;
|
2021-06-11 14:29:29 +00:00
|
|
|
|
|
|
|
hideLoader();
|
|
|
|
|
|
|
|
timer = setTimeout(() => TopLoaderService.start(), 500);
|
2020-09-23 15:42:47 +00:00
|
|
|
}
|
2020-11-17 03:29:24 +00:00
|
|
|
|
|
|
|
export { withLayoutSize } from "./withLayoutSize";
|
2020-12-04 11:21:51 +00:00
|
|
|
|
2021-02-17 14:53:18 +00:00
|
|
|
export function isMe(user, userName) {
|
|
|
|
return (
|
|
|
|
user && user.id && (userName === "@self" || user.userName === userName)
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2022-12-23 15:54:04 +00:00
|
|
|
export function isAdmin(currentUser) {
|
2022-07-28 13:11:55 +00:00
|
|
|
return (
|
|
|
|
currentUser.isAdmin ||
|
|
|
|
currentUser.isOwner ||
|
|
|
|
currentUser?.listAdminModules?.length > 0
|
|
|
|
);
|
2021-02-17 14:53:18 +00:00
|
|
|
}
|
2021-03-21 21:34:21 +00:00
|
|
|
|
2022-12-23 15:54:04 +00:00
|
|
|
export const getUserRole = (user) => {
|
|
|
|
if (user.isOwner) return "owner";
|
|
|
|
else if (isAdmin(user))
|
|
|
|
//TODO: Change to People Product Id const
|
|
|
|
return "admin";
|
|
|
|
//TODO: Need refactoring
|
|
|
|
else if (user.isVisitor) return "user";
|
2023-02-27 12:21:04 +00:00
|
|
|
else if (user.isCollaborator) return "collaborator";
|
2022-12-23 15:54:04 +00:00
|
|
|
else return "manager";
|
|
|
|
};
|
|
|
|
|
2021-03-22 14:35:33 +00:00
|
|
|
export const combineUrl = combineUrlFunc;
|
2021-04-05 12:49:02 +00:00
|
|
|
|
|
|
|
export function setCookie(name, value, options = {}) {
|
|
|
|
options = {
|
|
|
|
path: "/",
|
|
|
|
...options,
|
|
|
|
};
|
|
|
|
|
|
|
|
if (options.expires instanceof Date) {
|
|
|
|
options.expires = options.expires.toUTCString();
|
|
|
|
}
|
|
|
|
|
|
|
|
let updatedCookie =
|
|
|
|
encodeURIComponent(name) + "=" + encodeURIComponent(value);
|
|
|
|
|
|
|
|
for (let optionKey in options) {
|
|
|
|
updatedCookie += "; " + optionKey;
|
|
|
|
let optionValue = options[optionKey];
|
|
|
|
if (optionValue !== true) {
|
|
|
|
updatedCookie += "=" + optionValue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
document.cookie = updatedCookie;
|
|
|
|
}
|
|
|
|
|
|
|
|
export function deleteCookie(name) {
|
|
|
|
setCookie(name, "", {
|
|
|
|
"max-age": -1,
|
|
|
|
});
|
|
|
|
}
|
2021-04-16 17:23:08 +00:00
|
|
|
|
|
|
|
export function clickBackdrop() {
|
|
|
|
var elms = document.getElementsByClassName("backdrop-active");
|
|
|
|
if (elms && elms.length > 0) {
|
|
|
|
elms[0].click();
|
|
|
|
}
|
|
|
|
}
|
2021-04-29 10:44:37 +00:00
|
|
|
|
2021-04-30 14:25:26 +00:00
|
|
|
export function objectToGetParams(object) {
|
2021-04-29 10:44:37 +00:00
|
|
|
const params = Object.entries(object)
|
|
|
|
.filter(([, value]) => value !== undefined && value !== null)
|
|
|
|
.map(
|
|
|
|
([key, value]) =>
|
|
|
|
`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`
|
|
|
|
);
|
|
|
|
|
|
|
|
return params.length > 0 ? `?${params.join("&")}` : "";
|
|
|
|
}
|
2021-04-30 14:25:26 +00:00
|
|
|
|
|
|
|
export function toCommunityHostname(hostname) {
|
|
|
|
let communityHostname;
|
|
|
|
try {
|
|
|
|
communityHostname =
|
|
|
|
hostname.indexOf("m.") > -1
|
|
|
|
? hostname.substring(2, hostname.length)
|
|
|
|
: hostname;
|
|
|
|
} catch (e) {
|
|
|
|
console.error(e);
|
|
|
|
communityHostname = hostname;
|
|
|
|
}
|
|
|
|
|
|
|
|
return communityHostname;
|
|
|
|
}
|
2021-05-21 12:00:30 +00:00
|
|
|
|
2023-10-02 03:18:18 +00:00
|
|
|
export function getProviderTranslation(
|
|
|
|
provider,
|
|
|
|
t,
|
|
|
|
linked = false,
|
|
|
|
signUp = false
|
|
|
|
) {
|
2023-07-18 16:26:32 +00:00
|
|
|
const capitalizeProvider =
|
|
|
|
provider.charAt(0).toUpperCase() + provider.slice(1);
|
2023-04-11 11:21:17 +00:00
|
|
|
if (linked) {
|
2023-07-18 16:26:32 +00:00
|
|
|
return `${t("Common:Disconnect")} ${capitalizeProvider}`;
|
2023-04-11 11:21:17 +00:00
|
|
|
}
|
|
|
|
|
2021-05-21 12:00:30 +00:00
|
|
|
switch (provider) {
|
2023-09-14 11:32:28 +00:00
|
|
|
case "apple":
|
2023-09-15 15:32:32 +00:00
|
|
|
return signUp ? t("Common:SignUpWithApple") : t("Common:SignInWithApple");
|
2021-09-27 06:55:44 +00:00
|
|
|
case "google":
|
2023-10-02 03:18:18 +00:00
|
|
|
return signUp
|
|
|
|
? t("Common:SignUpWithGoogle")
|
|
|
|
: t("Common:SignInWithGoogle");
|
2021-09-27 06:55:44 +00:00
|
|
|
case "facebook":
|
2023-10-02 03:18:18 +00:00
|
|
|
return signUp
|
|
|
|
? t("Common:SignUpWithFacebook")
|
|
|
|
: t("Common:SignInWithFacebook");
|
2021-09-27 06:55:44 +00:00
|
|
|
case "twitter":
|
2023-10-02 03:18:18 +00:00
|
|
|
return signUp
|
|
|
|
? t("Common:SignUpWithTwitter")
|
|
|
|
: t("Common:SignInWithTwitter");
|
2021-09-27 06:55:44 +00:00
|
|
|
case "linkedin":
|
2023-10-02 03:18:18 +00:00
|
|
|
return signUp
|
|
|
|
? t("Common:SignUpWithLinkedIn")
|
|
|
|
: t("Common:SignInWithLinkedIn");
|
2023-08-29 03:26:37 +00:00
|
|
|
case "microsoft":
|
2023-10-02 03:18:18 +00:00
|
|
|
return signUp
|
|
|
|
? t("Common:SignUpWithMicrosoft")
|
|
|
|
: t("Common:SignInWithMicrosoft");
|
2022-02-02 22:10:12 +00:00
|
|
|
case "sso":
|
2023-09-15 15:32:32 +00:00
|
|
|
return signUp ? t("Common:SignUpWithSso") : t("Common:SignInWithSso");
|
2023-09-04 13:06:55 +00:00
|
|
|
case "zoom":
|
2023-09-15 15:32:32 +00:00
|
|
|
return signUp ? t("Common:SignUpWithZoom") : t("Common:SignInWithZoom");
|
2021-05-21 12:00:30 +00:00
|
|
|
}
|
|
|
|
}
|
2021-06-02 10:55:11 +00:00
|
|
|
|
2021-09-07 15:34:30 +00:00
|
|
|
export function getLanguage(lng) {
|
2021-06-02 10:55:11 +00:00
|
|
|
try {
|
2023-02-06 17:47:54 +00:00
|
|
|
if (!lng) return lng;
|
|
|
|
|
2021-06-02 10:55:11 +00:00
|
|
|
let language = lng == "en-US" || lng == "en-GB" ? "en" : lng;
|
|
|
|
|
|
|
|
const splitted = lng.split("-");
|
|
|
|
|
|
|
|
if (splitted.length == 2 && splitted[0] == splitted[1].toLowerCase()) {
|
|
|
|
language = splitted[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
return language;
|
|
|
|
} catch (error) {
|
|
|
|
console.error(error);
|
|
|
|
}
|
|
|
|
|
|
|
|
return lng;
|
|
|
|
}
|
|
|
|
|
2023-08-21 12:48:28 +00:00
|
|
|
export const isLanguageRtl = (lng: string) => {
|
|
|
|
if (!lng) return;
|
|
|
|
|
|
|
|
const splittedLng = lng.split("-");
|
|
|
|
return RtlLanguages.includes(splittedLng[0]);
|
|
|
|
};
|
|
|
|
|
|
|
|
// temporary function needed to replace rtl language in Editor to ltr
|
|
|
|
export const getLtrLanguageForEditor = (
|
|
|
|
userLng: string,
|
|
|
|
portalLng: string,
|
|
|
|
isEditor: boolean = false
|
|
|
|
): string => {
|
|
|
|
let isEditorPath;
|
|
|
|
if (typeof window !== "undefined") {
|
|
|
|
isEditorPath = window?.location.pathname.indexOf("doceditor") !== -1;
|
|
|
|
}
|
|
|
|
const isUserLngRtl = isLanguageRtl(userLng);
|
|
|
|
const isPortalLngRtl = isLanguageRtl(portalLng);
|
|
|
|
|
|
|
|
if ((!isEditor && !isEditorPath) || (userLng && !isUserLngRtl))
|
|
|
|
return userLng;
|
|
|
|
if (portalLng && !isPortalLngRtl) return portalLng;
|
|
|
|
|
|
|
|
return "en";
|
|
|
|
};
|
|
|
|
|
2021-08-19 10:30:15 +00:00
|
|
|
export function loadScript(url, id, onLoad, onError) {
|
|
|
|
try {
|
|
|
|
const script = document.createElement("script");
|
|
|
|
script.setAttribute("type", "text/javascript");
|
|
|
|
script.setAttribute("id", id);
|
|
|
|
|
|
|
|
if (onLoad) script.onload = onLoad;
|
|
|
|
if (onError) script.onerror = onError;
|
|
|
|
|
|
|
|
script.src = url;
|
|
|
|
script.async = true;
|
|
|
|
|
|
|
|
document.body.appendChild(script);
|
|
|
|
} catch (e) {
|
|
|
|
console.error(e);
|
|
|
|
}
|
2022-07-21 15:05:23 +00:00
|
|
|
}
|
2021-10-13 12:19:31 +00:00
|
|
|
|
|
|
|
export function isRetina() {
|
|
|
|
if (window.devicePixelRatio > 1) return true;
|
|
|
|
|
|
|
|
var mediaQuery =
|
|
|
|
"(-webkit-min-device-pixel-ratio: 1.5),\
|
|
|
|
(min--moz-device-pixel-ratio: 1.5),\
|
|
|
|
(-o-min-device-pixel-ratio: 3/2),\
|
|
|
|
(min-resolution: 1.5dppx),\
|
|
|
|
(min-device-pixel-ratio: 1.5)";
|
|
|
|
|
|
|
|
if (window.matchMedia && window.matchMedia(mediaQuery).matches) return true;
|
|
|
|
return false;
|
|
|
|
}
|
2021-12-23 11:01:08 +00:00
|
|
|
|
|
|
|
export function convertLanguage(key) {
|
|
|
|
switch (key) {
|
2022-09-06 09:52:57 +00:00
|
|
|
case "en":
|
|
|
|
return "en-GB";
|
2021-12-23 11:01:08 +00:00
|
|
|
case "ru-RU":
|
|
|
|
return "ru";
|
|
|
|
case "de-DE":
|
|
|
|
return "de";
|
|
|
|
case "it-IT":
|
|
|
|
return "it";
|
|
|
|
case "fr-FR":
|
|
|
|
return "fr";
|
|
|
|
}
|
|
|
|
|
|
|
|
return key;
|
|
|
|
}
|
2022-04-15 11:03:20 +00:00
|
|
|
|
2023-08-21 21:30:34 +00:00
|
|
|
export function convertToCulture(key: string) {
|
|
|
|
switch (key) {
|
2023-11-01 16:23:15 +00:00
|
|
|
case "ar":
|
|
|
|
return "ar-SA";
|
2023-08-21 21:30:34 +00:00
|
|
|
case "en":
|
|
|
|
return "en-US";
|
|
|
|
case "el":
|
|
|
|
return "el-GR";
|
|
|
|
case "hy":
|
|
|
|
return "hy-AM";
|
|
|
|
case "ko":
|
|
|
|
return "ko-KR";
|
|
|
|
case "lo":
|
|
|
|
return "lo-LA";
|
|
|
|
case "pt":
|
|
|
|
return "pt-BR";
|
|
|
|
case "uk":
|
|
|
|
return "uk-UA";
|
|
|
|
case "ja":
|
|
|
|
return "ja-JP";
|
|
|
|
case "zh":
|
|
|
|
return "zh-CN";
|
|
|
|
}
|
2023-10-25 07:38:01 +00:00
|
|
|
return key;
|
|
|
|
}
|
2023-08-21 21:30:34 +00:00
|
|
|
|
2023-10-25 07:38:01 +00:00
|
|
|
export function convertToLanguage(key: string) {
|
2023-11-01 16:23:15 +00:00
|
|
|
const splittedKey = key.split("-");
|
|
|
|
if (splittedKey.length > 1) return splittedKey[0];
|
|
|
|
|
2023-08-21 21:30:34 +00:00
|
|
|
return key;
|
|
|
|
}
|
|
|
|
|
2022-04-28 19:05:43 +00:00
|
|
|
export function sleep(ms) {
|
|
|
|
return new Promise((resolve) => setTimeout(resolve, ms));
|
|
|
|
}
|
2022-05-13 16:16:28 +00:00
|
|
|
|
|
|
|
export function isElementInViewport(el) {
|
|
|
|
if (!el) return;
|
|
|
|
|
|
|
|
const rect = el.getBoundingClientRect();
|
|
|
|
|
|
|
|
return (
|
|
|
|
rect.top >= 0 &&
|
|
|
|
rect.left >= 0 &&
|
|
|
|
rect.bottom <=
|
2023-10-02 03:18:18 +00:00
|
|
|
(window.innerHeight || document.documentElement.clientHeight) &&
|
2022-05-13 16:16:28 +00:00
|
|
|
rect.right <= (window.innerWidth || document.documentElement.clientWidth)
|
|
|
|
);
|
|
|
|
}
|
2022-06-28 16:31:28 +00:00
|
|
|
|
|
|
|
export function assign(obj, keyPath, value) {
|
|
|
|
const lastKeyIndex = keyPath.length - 1;
|
|
|
|
for (let i = 0; i < lastKeyIndex; ++i) {
|
|
|
|
const key = keyPath[i];
|
|
|
|
if (!(key in obj)) {
|
|
|
|
obj[key] = {};
|
|
|
|
}
|
|
|
|
obj = obj[key];
|
|
|
|
}
|
|
|
|
obj[keyPath[lastKeyIndex]] = value;
|
|
|
|
}
|
2022-08-03 11:48:54 +00:00
|
|
|
|
2022-08-26 21:49:06 +00:00
|
|
|
export function getOAuthToken(
|
|
|
|
tokenGetterWin: Window | string | null
|
|
|
|
): Promise<string> {
|
2022-08-15 14:27:40 +00:00
|
|
|
return new Promise((resolve, reject) => {
|
|
|
|
localStorage.removeItem("code");
|
2022-08-26 21:49:06 +00:00
|
|
|
let interval: ReturnType<typeof setInterval>;
|
2022-08-15 14:27:40 +00:00
|
|
|
interval = setInterval(() => {
|
|
|
|
try {
|
|
|
|
const code = localStorage.getItem("code");
|
2022-08-26 21:49:06 +00:00
|
|
|
if (typeof tokenGetterWin !== "string") {
|
|
|
|
if (code) {
|
|
|
|
localStorage.removeItem("code");
|
|
|
|
clearInterval(interval);
|
|
|
|
resolve(code);
|
|
|
|
} else if (tokenGetterWin && tokenGetterWin.closed) {
|
|
|
|
clearInterval(interval);
|
|
|
|
reject();
|
|
|
|
}
|
2022-08-15 14:27:40 +00:00
|
|
|
}
|
|
|
|
} catch (e) {
|
|
|
|
clearInterval(interval);
|
|
|
|
reject(e);
|
|
|
|
}
|
|
|
|
}, 500);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2022-08-26 21:49:06 +00:00
|
|
|
export function getLoginLink(token: string, code: string) {
|
2022-12-20 16:51:49 +00:00
|
|
|
return combineUrl(
|
|
|
|
window.DocSpaceConfig?.proxy?.url,
|
|
|
|
`/login.ashx?p=${token}&code=${code}`
|
|
|
|
);
|
2022-08-15 14:27:40 +00:00
|
|
|
}
|
2022-08-17 08:19:49 +00:00
|
|
|
|
|
|
|
export function checkIsSSR() {
|
|
|
|
return typeof window === "undefined";
|
|
|
|
}
|
2022-08-24 07:17:39 +00:00
|
|
|
|
2022-12-21 11:44:05 +00:00
|
|
|
export const frameCallbackData = (methodReturnData: any) => {
|
2022-08-03 11:48:54 +00:00
|
|
|
window.parent.postMessage(
|
|
|
|
JSON.stringify({
|
|
|
|
type: "onMethodReturn",
|
2022-12-21 11:44:05 +00:00
|
|
|
methodReturnData,
|
2022-08-03 11:48:54 +00:00
|
|
|
}),
|
|
|
|
"*"
|
|
|
|
);
|
|
|
|
};
|
2022-08-04 10:29:42 +00:00
|
|
|
|
2023-07-18 16:26:32 +00:00
|
|
|
export const frameCallEvent = (eventReturnData: any) => {
|
|
|
|
window.parent.postMessage(
|
|
|
|
JSON.stringify({
|
|
|
|
type: "onEventReturn",
|
|
|
|
eventReturnData,
|
|
|
|
}),
|
|
|
|
"*"
|
|
|
|
);
|
|
|
|
};
|
|
|
|
|
2022-12-21 11:44:05 +00:00
|
|
|
export const frameCallCommand = (commandName: string, commandData: any) => {
|
2022-08-04 10:29:42 +00:00
|
|
|
window.parent.postMessage(
|
|
|
|
JSON.stringify({
|
|
|
|
type: "onCallCommand",
|
2022-12-21 11:44:05 +00:00
|
|
|
commandName,
|
|
|
|
commandData,
|
2022-08-04 10:29:42 +00:00
|
|
|
}),
|
|
|
|
"*"
|
|
|
|
);
|
|
|
|
};
|
2022-09-14 13:01:40 +00:00
|
|
|
|
2023-03-28 10:37:31 +00:00
|
|
|
export const getConvertedSize = (t, bytes) => {
|
2023-03-28 10:31:41 +00:00
|
|
|
let power = 0,
|
2023-03-28 10:37:31 +00:00
|
|
|
resultSize = bytes;
|
2023-03-28 10:31:41 +00:00
|
|
|
|
|
|
|
const sizeNames = [
|
|
|
|
t("Common:Bytes"),
|
|
|
|
t("Common:Kilobyte"),
|
|
|
|
t("Common:Megabyte"),
|
|
|
|
t("Common:Gigabyte"),
|
|
|
|
t("Common:Terabyte"),
|
|
|
|
t("Common:Petabyte"),
|
|
|
|
t("Common:Exabyte"),
|
|
|
|
];
|
|
|
|
|
|
|
|
if (bytes <= 0) return `${"0" + " " + t("Common:Bytes")}`;
|
|
|
|
|
|
|
|
if (bytes >= 1024) {
|
|
|
|
power = Math.floor(Math.log(bytes) / Math.log(1024));
|
|
|
|
power = power < sizeNames.length ? power : sizeNames.length - 1;
|
|
|
|
resultSize = parseFloat((bytes / Math.pow(1024, power)).toFixed(2));
|
|
|
|
}
|
2022-09-14 13:01:40 +00:00
|
|
|
|
2023-03-28 10:31:41 +00:00
|
|
|
return resultSize + " " + sizeNames[power];
|
2022-09-14 13:01:40 +00:00
|
|
|
};
|
2022-10-24 10:01:43 +00:00
|
|
|
|
2023-02-07 15:31:06 +00:00
|
|
|
export const getBgPattern = (colorSchemeId: number | undefined) => {
|
2022-10-24 10:01:43 +00:00
|
|
|
switch (colorSchemeId) {
|
|
|
|
case 1:
|
2022-12-29 09:26:20 +00:00
|
|
|
return `url('${BackgroundPatternReactSvgUrl}')`;
|
2022-10-24 10:01:43 +00:00
|
|
|
case 2:
|
2022-12-29 09:26:20 +00:00
|
|
|
return `url('${BackgroundPatternOrangeReactSvgUrl}')`;
|
2022-10-24 10:01:43 +00:00
|
|
|
case 3:
|
2022-12-29 09:26:20 +00:00
|
|
|
return `url('${BackgroundPatternGreenReactSvgUrl}')`;
|
2022-10-24 10:01:43 +00:00
|
|
|
case 4:
|
2022-12-29 09:26:20 +00:00
|
|
|
return `url('${BackgroundPatternRedReactSvgUrl}')`;
|
2022-10-24 10:01:43 +00:00
|
|
|
case 5:
|
2022-12-29 09:26:20 +00:00
|
|
|
return `url('${BackgroundPatternPurpleReactSvgUrl}')`;
|
2022-10-24 10:01:43 +00:00
|
|
|
case 6:
|
2022-12-29 09:26:20 +00:00
|
|
|
return `url('${BackgroundPatternLightBlueReactSvgUrl}')`;
|
2022-10-24 10:01:43 +00:00
|
|
|
case 7:
|
2022-12-29 09:26:20 +00:00
|
|
|
return `url('${BackgroundPatternBlackReactSvgUrl}')`;
|
2022-10-24 10:01:43 +00:00
|
|
|
default:
|
2022-12-29 09:26:20 +00:00
|
|
|
return `url('${BackgroundPatternReactSvgUrl}')`;
|
2022-10-24 10:01:43 +00:00
|
|
|
}
|
|
|
|
};
|
2022-12-27 14:04:56 +00:00
|
|
|
|
|
|
|
export const getLogoFromPath = (path) => {
|
|
|
|
if (!path || path.indexOf("images/logo/") === -1) return path;
|
|
|
|
|
|
|
|
const name = path.split("/").pop();
|
2023-01-11 08:35:11 +00:00
|
|
|
|
2022-12-27 14:04:56 +00:00
|
|
|
switch (name) {
|
|
|
|
case "aboutpage.svg":
|
|
|
|
case "loginpage.svg":
|
|
|
|
return LoginPageSvgUrl;
|
|
|
|
case "dark_loginpage.svg":
|
|
|
|
return DarkLoginPageSvgUrl;
|
|
|
|
case "leftmenu.svg":
|
|
|
|
case "dark_leftmenu.svg":
|
|
|
|
return LeftMenuSvgUrl;
|
|
|
|
case "dark_aboutpage.svg":
|
|
|
|
case "dark_lightsmall.svg":
|
|
|
|
return DarkLightSmallSvgUrl;
|
|
|
|
case "docseditor.svg":
|
|
|
|
return DocseditorSvgUrl;
|
|
|
|
case "lightsmall.svg":
|
|
|
|
return LightSmallSvgUrl;
|
|
|
|
case "docseditorembed.svg":
|
|
|
|
return DocsEditoRembedSvgUrl;
|
2023-01-11 08:35:11 +00:00
|
|
|
case "favicon.ico":
|
2023-01-24 14:37:18 +00:00
|
|
|
return FaviconIco;
|
2022-12-27 14:04:56 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return path;
|
|
|
|
};
|
2023-04-07 14:23:34 +00:00
|
|
|
|
2023-07-18 16:26:32 +00:00
|
|
|
export const getDaysLeft = (date) => {
|
|
|
|
return moment(date).startOf("day").diff(moment().startOf("day"), "days");
|
|
|
|
};
|
2023-04-07 14:23:34 +00:00
|
|
|
export const getDaysRemaining = (autoDelete) => {
|
2023-07-18 16:26:32 +00:00
|
|
|
let daysRemaining = getDaysLeft(autoDelete);
|
2023-04-07 14:23:34 +00:00
|
|
|
|
|
|
|
if (daysRemaining <= 0) return "<1";
|
|
|
|
return "" + daysRemaining;
|
|
|
|
};
|
2023-05-29 14:14:50 +00:00
|
|
|
|
|
|
|
export const checkFilterInstance = (filterObject, certainClass) => {
|
|
|
|
const isInstance =
|
|
|
|
filterObject.constructor.name === certainClass.prototype.constructor.name;
|
|
|
|
|
|
|
|
if (!isInstance)
|
|
|
|
throw new Error(
|
|
|
|
`Filter ${filterObject.constructor.name} isn't an instance of ${certainClass.prototype.constructor.name}`
|
|
|
|
);
|
|
|
|
|
|
|
|
return isInstance;
|
|
|
|
};
|
2023-07-18 16:26:32 +00:00
|
|
|
|
|
|
|
export const getFileExtension = (fileTitle: string) => {
|
|
|
|
if (!fileTitle) {
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
fileTitle = fileTitle.trim();
|
|
|
|
const posExt = fileTitle.lastIndexOf(".");
|
|
|
|
return 0 <= posExt ? fileTitle.substring(posExt).trim().toLowerCase() : "";
|
|
|
|
};
|
|
|
|
|
|
|
|
export const getSystemTheme = () => {
|
|
|
|
const isDesktopClient = window["AscDesktopEditor"] !== undefined;
|
2023-08-23 12:44:39 +00:00
|
|
|
const desktopClientTheme = window?.RendererProcessVariable?.theme;
|
2023-09-04 13:06:55 +00:00
|
|
|
const isDark =
|
|
|
|
desktopClientTheme?.id === "theme-dark" ||
|
|
|
|
desktopClientTheme?.id === "theme-contrast-dark" ||
|
|
|
|
(desktopClientTheme?.id === "theme-system" &&
|
|
|
|
desktopClientTheme?.system === "dark");
|
2023-08-23 12:44:39 +00:00
|
|
|
|
2023-07-18 16:26:32 +00:00
|
|
|
return isDesktopClient
|
2023-08-23 12:44:39 +00:00
|
|
|
? isDark
|
2023-07-18 16:26:32 +00:00
|
|
|
? ThemeKeys.DarkStr
|
|
|
|
: ThemeKeys.BaseStr
|
|
|
|
: window.matchMedia &&
|
|
|
|
window.matchMedia("(prefers-color-scheme: dark)").matches
|
2023-10-02 03:18:18 +00:00
|
|
|
? ThemeKeys.DarkStr
|
|
|
|
: ThemeKeys.BaseStr;
|
2023-07-18 16:26:32 +00:00
|
|
|
};
|
2023-10-26 11:43:39 +00:00
|
|
|
|
|
|
|
export const getEditorTheme = (theme) => {
|
|
|
|
switch (theme) {
|
|
|
|
case ThemeKeys.BaseStr:
|
|
|
|
return "default-light";
|
|
|
|
case ThemeKeys.DarkStr:
|
|
|
|
return "default-dark";
|
|
|
|
case ThemeKeys.SystemStr: {
|
|
|
|
const uiTheme = getSystemTheme();
|
|
|
|
return uiTheme === ThemeKeys.DarkStr ? "default-dark" : "default-light";
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
return "default-dark";
|
|
|
|
}
|
|
|
|
};
|