diff --git a/static/js/VersionBlock/VersionTitleAndSelector.jsx b/static/js/VersionBlock/VersionTitleAndSelector.jsx
index 2bcfb66028..78a4a827ac 100644
--- a/static/js/VersionBlock/VersionTitleAndSelector.jsx
+++ b/static/js/VersionBlock/VersionTitleAndSelector.jsx
@@ -12,7 +12,8 @@ function VersionTitleAndSelector({currentRef, version, currObjectVersions, openV
}
return shortVersionTitle;
}
- const openVersionInMainPanel = VersionBlockUtils.openVersionInMainPanel.bind(null, currentRef, version, currObjectVersions, 'select-button',
+ const renderMode = 'translation'; //for now this component is only rendered from TranslationsBox
+ const openVersionInMainPanel = VersionBlockUtils.openVersionInMainPanel.bind(null, currentRef, version, currObjectVersions, renderMode,
null, openVersionInReader);
const buttonText = isSelected ? 'Currently Selected' : 'Select';
return (
diff --git a/static/js/VersionsTextList.jsx b/static/js/VersionsTextList.jsx
new file mode 100644
index 0000000000..21a89f4c5a
--- /dev/null
+++ b/static/js/VersionsTextList.jsx
@@ -0,0 +1,103 @@
+import React, {useEffect, useState} from "react";
+import Sefaria from "./sefaria/sefaria";
+import {LoadingMessage} from "./Misc";
+import {RecentFilterSet} from "./ConnectionFilters";
+import TextRange from "./TextRange";
+import {AddConnectionToSheetButton, ConnectionButtons, OpenConnectionTabButton} from "./TextList";
+import PropTypes from "prop-types";
+
+export const VersionsTextList = ({
+ srefs,
+ vFilter,
+ recentVFilters,
+ setFilter,
+ onRangeClick,
+ onCitationClick,
+ translationLanguagePreference,
+ setConnectionsMode,
+ versionLangMap,
+ }) => {
+ const [loaded, setLoaded] = useState(false);
+
+ useEffect(() => {
+ const preloadText = async (filter) => {
+ if (filter.length) {
+ setLoaded(false);
+ const sectionRef = getSectionRef();
+ const [vTitle, language] = Sefaria.deconstructVersionsKey(filter[0]);
+ let enVersion = null, heVersion = null;
+ if (language === "en") {
+ enVersion = vTitle;
+ } else {
+ heVersion = vTitle;
+ }
+ await Sefaria.getRef(sectionRef, currSelectedVersions);
+ setLoaded(true);
+ }
+ };
+
+ preloadText(vFilter);
+ }, [vFilter]);
+
+
+ const getSectionRef = () => {
+ const ref = srefs[0]; // TODO account for selections spanning sections
+ return Sefaria.sectionRef(ref) || ref;
+ };
+
+ const getVersion = () => {
+ return Object.values(versionLangMap).flat().filter(
+ v => Sefaria.getTranslateVersionsKey(v.versionTitle, v.language) === vFilter[0]
+ )[0];
+ };
+
+ if (!loaded || !vFilter.length) {
+ return
;
+ }
+
+ const {languageFamilyName, versionTitle, language, isPrimary} = getVersion()
+ const pseudoLanguage = (isPrimary) ? 'he' : 'en';
+ const currSelectedVersions = {[pseudoLanguage]: {versionTitle, languageFamilyName}};
+ const handleRangeClick = (sref) => {
+ onRangeClick(sref, false, currSelectedVersions);
+ };
+
+ return (
+
+
+
+
+
+
+ {/*use language for sheets because there language means direction*/}
+
+
+ );
+};
+VersionsTextList.propTypes = {
+ srefs: PropTypes.array,
+ vFilter: PropTypes.array,
+ recentVFilters: PropTypes.array,
+ setFilter: PropTypes.func.isRequired,
+ onRangeClick: PropTypes.func.isRequired,
+ onCitationClick: PropTypes.func.isRequired,
+ translationLanguagePreference: PropTypes.string,
+ setConnectionsMode: PropTypes.func.isRequired,
+ versionLangMap: PropTypes.object.isRequired,
+};
diff --git a/static/js/common/DropdownMenu.jsx b/static/js/common/DropdownMenu.jsx
new file mode 100644
index 0000000000..30a26eea2b
--- /dev/null
+++ b/static/js/common/DropdownMenu.jsx
@@ -0,0 +1,36 @@
+import React, {createContext, useContext, useRef, useState} from 'react';
+import PropTypes from "prop-types";
+import {useOutsideClick} from "../Hooks";
+
+const FallbackContext = createContext(null);
+
+const useIsMenuOpen = (context) => {
+ //React must have the same hooks any time, so we should have context and state any way.
+ //For that we also define FallbackContext. It's defined outside for not be created in any use but only once.
+ const contextValue = useContext(context || FallbackContext);
+ const [stateIsMenuOpen, stateSetIsMenuOpen] = useState(false);
+ return contextValue ? [contextValue.isMenuOpen, contextValue.setIsMenuOpen] : [stateIsMenuOpen, stateSetIsMenuOpen];
+}
+
+const DropdownMenu = ({buttonContent, menu, context=null}) => {
+ /**
+ context - if provided, would be used for menu opening (which also be available outside.
+ if not, will use state (and the opening won't be availabe in the parent component)
+ */
+ const [isMenuOpen, setIsMenuOpen] = useIsMenuOpen(context);
+ const wrapperRef = useRef(null);
+ useOutsideClick(wrapperRef, () => setIsMenuOpen(false), isMenuOpen);
+ const onClick = () => setIsMenuOpen(!isMenuOpen)
+
+ return (
+
+
+ {isMenuOpen && menu}
+
+ );
+};
+DropdownMenu.propTypes = {
+ buttonContent: PropTypes.elementType.isRequired,
+ menu: PropTypes.elementType.isRequired,
+};
+export default DropdownMenu;
diff --git a/static/js/common/ToggleSwitch.jsx b/static/js/common/ToggleSwitch.jsx
new file mode 100644
index 0000000000..3b303472f8
--- /dev/null
+++ b/static/js/common/ToggleSwitch.jsx
@@ -0,0 +1,31 @@
+import React from "react";
+import PropTypes from "prop-types";
+
+function ToggleSwitch({name, disabled, onChange, isChecked}) {
+ return (
+
+ );
+}
+ToggleSwitch.propTypes = {
+ name: PropTypes.string,
+ disabled: PropTypes.bool,
+ onChange: PropTypes.func.isRequired,
+ isChecked: PropTypes.bool.isRequired,
+};
+export default ToggleSwitch;
diff --git a/static/js/common/ToggleSwitchLine.jsx b/static/js/common/ToggleSwitchLine.jsx
new file mode 100644
index 0000000000..1e670e1a0e
--- /dev/null
+++ b/static/js/common/ToggleSwitchLine.jsx
@@ -0,0 +1,27 @@
+import React from "react";
+import PropTypes from "prop-types";
+import ToggleSwitch from "./ToggleSwitch";
+import {InterfaceText} from "../Misc";
+
+function ToggleSwitchLine({name, onChange, isChecked, text, disabled=false}) {
+ return (
+
+ {text}
+
+
+ );
+}
+ToggleSwitchLine.propTypes = {
+ name: PropTypes.string,
+ disabled: PropTypes.bool,
+ text: PropTypes.string,
+ onChange: PropTypes.func.isRequired,
+ isChecked: PropTypes.bool.isRequired,
+};
+export default ToggleSwitchLine;
diff --git a/static/js/constants.js b/static/js/constants.js
new file mode 100644
index 0000000000..a55f2ad492
--- /dev/null
+++ b/static/js/constants.js
@@ -0,0 +1,6 @@
+export const layoutOptions = {
+ 'mono': ['continuous', 'segmented'],
+ 'bi-rtl': ['stacked', 'heRight'],
+ 'bi-ltr': ['stacked', 'heLeft'],
+ 'mixed': ['stacked', 'heLeft', 'heRight'],
+};
diff --git a/static/js/context.js b/static/js/context.js
index 129b99a4be..3939d6b457 100644
--- a/static/js/context.js
+++ b/static/js/context.js
@@ -1,9 +1,9 @@
import React, { useContext, useEffect, useState } from "react";
-const ContentLanguageContext = React.createContext({
+const ReaderPanelContext = React.createContext({
language: "english",
});
-ContentLanguageContext.displayName = "ContentLanguageContext"; //This lets us see this name in the devtools
+ReaderPanelContext.displayName = "ContentLanguageContext"; //This lets us see this name in the devtools
const AdContext = React.createContext({});
AdContext.displayName = "AdContext";
@@ -330,7 +330,7 @@ function StrapiDataProvider({ children }) {
}
export {
- ContentLanguageContext,
+ ReaderPanelContext,
AdContext,
StrapiDataProvider,
StrapiDataContext,
diff --git a/static/js/sefaria/api.js b/static/js/sefaria/api.js
new file mode 100644
index 0000000000..2ba8834328
--- /dev/null
+++ b/static/js/sefaria/api.js
@@ -0,0 +1,15 @@
+// export default async function read(url, headers = {}) {
+// const response = await fetch(url, {
+// method: 'GET',
+// headers: headers,
+// credentials: 'include',
+// });
+// return response.json();
+// }
+
+import Sefaria from "./sefaria";
+
+export default async function read(url) {
+ const r = await Sefaria._ApiPromise(url);
+ return r;
+}
\ No newline at end of file
diff --git a/static/js/sefaria/sefaria.js b/static/js/sefaria/sefaria.js
index a33e3d3f65..4c587fdf67 100644
--- a/static/js/sefaria/sefaria.js
+++ b/static/js/sefaria/sefaria.js
@@ -461,7 +461,7 @@ Sefaria = extend(Sefaria, {
//swap out original versions from the server with the ones that Sefaria client side has sorted and updated with some fields.
// This happens before saving the text to cache so that both caches are consistent
if(d?.versions?.length){
- let versions = Sefaria._saveVersions(d.sectionRef, d.versions);
+ let versions = Sefaria.saveVersions(d.sectionRef, d.versions);
d.versions = Sefaria._makeVersions(versions, false);
}
Sefaria._saveText(d, settings);
@@ -540,29 +540,124 @@ Sefaria = extend(Sefaria, {
return language;
}
},
- makeUrlForAPIV3Text: function(ref, requiredVersions, mergeText) {
+ makeUrlForAPIV3Text: function(ref, requiredVersions, mergeText, return_format) {
const host = Sefaria.apiHost;
const endPoint = '/api/v3/texts/';
const versions = requiredVersions.map(obj =>
- Sefaria.makeParamsStringForAPIV3(obj.language, obj.versionTitle)
+ Sefaria.makeParamsStringForAPIV3(obj.languageFamilyName, obj.versionTitle)
);
const mergeTextInt = mergeText ? 1 : 0;
- const url = `${host}${endPoint}${ref}?version=${versions.join('&version=')}&fill_in_missing_segments=${mergeTextInt}`;
+ const return_format_string = (return_format) ? `&return_format=${return_format}` : '';
+ const url = `${host}${endPoint}${ref}?version=${versions.join('&version=')}&fill_in_missing_segments=${mergeTextInt}${return_format_string}`;
return url;
},
- getTextsFromAPIV3: async function(ref, requiredVersions, mergeText) {
+ _textsStore: {},
+ getTextsFromAPIV3: async function(ref, requiredVersions, mergeText, return_format) {
// ref is segment ref or bottom level section ref
- // requiredVersions is array of objects that can have language and versionTitle
- const url = Sefaria.makeUrlForAPIV3Text(ref, requiredVersions, mergeText);
- //TODO here's the place for getting it from cache
- const apiObject = await Sefaria._ApiPromise(url);
- //TODO here's the place for all changes we want to add, and saving in cache
+ // requiredVersions is array of objects that can have languageFamilyName and versionTitle
+ const url = Sefaria.makeUrlForAPIV3Text(ref, requiredVersions, mergeText, return_format);
+ const apiObject = await Sefaria._cachedApiPromise({url: url, key: url, store: Sefaria._textsStore});
+ this._textsStore[ref] = apiObject;
return apiObject;
},
getAllTranslationsWithText: async function(ref) {
- let returnObj = await Sefaria.getTextsFromAPIV3(ref, [{language: 'translation', versionTitle: 'all'}], false);
+ let returnObj = await Sefaria.getTextsFromAPIV3(ref, [{languageFamilyName: 'translation', versionTitle: 'all'}], false);
return Sefaria._sortVersionsIntoBuckets(returnObj.versions);
},
+ getPrimaryAndTranslationFromVersions: function(versions) {
+ let primary, translation;
+ if (versions.length === 1) {
+ primary = versions[0];
+ translation = {text: []};
+ } else if (versions[0].isPrimary && !versions[1].isSource) {
+ [primary, translation] = versions;
+ } else {
+ [translation, primary] = versions;
+ }
+ return [primary, translation];
+ },
+ _adaptApiResponse: function(versionsResponse) {
+ /**
+ * takes an api-v3 texts response for primary and translation versions, and adapt it to the expected 'old' result.
+ * it adds the texts to 'he' and 'text', and the sources to 'sources' and 'heSources'
+ */
+ const versions = versionsResponse.versions;
+ const [primary, translation] = Sefaria.getPrimaryAndTranslationFromVersions(versions);
+ ({ text: versionsResponse.text, versionTitle: versionsResponse.versionTitle, direction: versionsResponse.translationDirection, languageFamilyName: versionsResponse.translationLang, status: versionsResponse.versionStatus } = translation);
+ ({ text: versionsResponse.he, versionTitle: versionsResponse.heVersionTitle, direction: versionsResponse.primaryDirection, languageFamilyName: versionsResponse.primaryLang, status: versionsResponse.heVersionStatus } = primary);
+ if (translation.sources && !translation.sources.every(source => source === translation.sources[0])) {
+ versionsResponse.sources = translation.sources;
+ }
+ if (primary.sources && primary.sources.every(source => source === primary.sources[0])) {
+ versionsResponse.heSources = primary.sources;
+ }
+ },
+ _findInVresions: function (query, versions) {
+ query = Object.fromEntries(
+ Object.entries(query).filter(([_, value]) => value != null) // filters also undefined
+ );
+ return versions.reduce((maxObj, current) => (
+ Object.entries(query).every(([key, value]) => current[key] === value) &&
+ (current.priority || 0) > (maxObj?.priority ?? -1) ?
+ current : maxObj
+ ), null)
+ },
+ _getVersionObjects: async function(ref, primaryVersionObj, translationVersionObj, translationLanguagePreference) {
+ const versions = await Sefaria.getVersions(ref);
+ const flatVersions = Object.values(versions).flat();
+ primaryVersionObj = Sefaria._findInVresions({...primaryVersionObj, isPrimary: true}, flatVersions);
+ if (primaryVersionObj) {
+ const {languageFamilyName, versionTitle} = primaryVersionObj;
+ primaryVersionObj = {languageFamilyName, versionTitle};
+ } else {
+ primaryVersionObj = {languageFamilyName: 'primary'}
+ }
+ if (translationVersionObj.versionTitle) {
+ translationVersionObj = Sefaria._findInVresions({...translationVersionObj, isSource: false}, flatVersions);
+ }
+ if (!translationVersionObj?.versionTitle) {
+ let requiredVersion;
+ const preferredTranslation = Sefaria.versionPreferences.getVersionPref(ref)?.en;
+ if (preferredTranslation) {
+ requiredVersion = Sefaria._findInVresions({isSource: false, versionTitle: preferredTranslation}, flatVersions);
+ }
+ if (!requiredVersion && translationLanguagePreference) {
+ const langVersions = versions[translationLanguagePreference] || [];
+ requiredVersion = Sefaria._findInVresions({isSource: false}, langVersions);
+ }
+ if (requiredVersion) {
+ const {languageFamilyName, versionTitle} = requiredVersion;
+ translationVersionObj = {languageFamilyName, versionTitle};
+ } else {
+ translationVersionObj = {languageFamilyName: 'translation'};
+ }
+ }
+ return [primaryVersionObj, translationVersionObj];
+ },
+ _getPrimaryAndTranslationText: async function(ref, primaryVersionObj, translationVersionObj, translationLanguagePreference) {
+ // versionObjs are objects with language and versionTitle
+ const requiredVersions = await Sefaria._getVersionObjects(ref, primaryVersionObj, translationVersionObj, translationLanguagePreference);
+ const versionsResponse = await Sefaria.getTextsFromAPIV3(ref, requiredVersions, true, 'wrap_all_entities');
+ Sefaria._adaptApiResponse(versionsResponse);
+ return versionsResponse;
+ },
+ getTextFromCurrVersions: async function(ref, currVersions, translationLanguagePreference, withContext) {
+ let {he, en} = currVersions;
+ if (!he?.languageFamilyName) {he = {languageFamilyName: 'primary'};}
+ if (!en?.languageFamilyName) {en = {languageFamilyName: 'translation'};}
+ let data = await Sefaria._getPrimaryAndTranslationText(ref, he, en, translationLanguagePreference);
+ if (withContext && data.textDepth === data.sections.length) {
+ const {text, he, alts} = await Sefaria.getTextFromCurrVersions(data.sectionRef, currVersions, translationLanguagePreference);
+ data = {
+ ...data,
+ text,
+ he,
+ alts,
+ };
+ }
+ this._saveText(data)
+ return data;
+ },
_bulkSheets: {},
getBulkSheets: function(sheetIds) {
if (sheetIds.length === 0) { return Promise.resolve({}); }
@@ -589,7 +684,7 @@ Sefaria = extend(Sefaria, {
this._api(Sefaria.apiHost + this._textUrl(ref, settings), function(data) {
//save versions and then text so both caches have updated versions
if(data?.versions?.length){
- let versions = this._saveVersions(data.sectionRef, data.versions);
+ let versions = this.saveVersions(data.sectionRef, data.versions);
data.versions = this._makeVersions(versions, false);
}
this._saveText(data, settings);
@@ -639,7 +734,7 @@ Sefaria = extend(Sefaria, {
if(!versionsInCache) {
const url = Sefaria.apiHost + "/api/texts/versions/" + Sefaria.normRef(ref);
await this._ApiPromise(url).then(d => {
- this._saveVersions(ref, d);
+ this.saveVersions(ref, d);
});
}
return Promise.resolve(this._versions[ref]);
@@ -769,7 +864,7 @@ Sefaria = extend(Sefaria, {
_makeVersions: function(versions, byLang){
return byLang ? versions : Object.values(versions).flat();
},
- _saveVersions: function(ref, versions){
+ saveVersions: function(ref, versions){
for (let v of versions) {
Sefaria._translateVersions[Sefaria.getTranslateVersionsKey(v.versionTitle, v.language)] = {
en: v.versionTitle,
@@ -1043,6 +1138,13 @@ Sefaria = extend(Sefaria, {
}
return data;
}, */
+ areCurrVersionObjectsEqual: function(version1, version2) {
+ return version1?.versionTitle === version2?.versionTitle && version1?.languageFamilyName === version2?.languageFamilyName;
+ },
+ areBothVersionsEqual(currVersions1, currVersions2) {
+ return Sefaria.areCurrVersionObjectsEqual(currVersions1?.en, currVersions2?.en) &&
+ Sefaria.areCurrVersionObjectsEqual(currVersions1?.he, currVersions2?.he);
+ },
_index: {}, // Cache for text index records
index: function(text, index) {
if (!index) {
@@ -1167,26 +1269,12 @@ Sefaria = extend(Sefaria, {
if (versionedKey) { return this._getOrBuildTextData(versionedKey); }
return null;
},
- getRef: function(ref) {
+ getRef: function(ref, currVersions=null) {
// Returns Promise for parsed ref info
+ // currVersions is enabling getting text from cache
+ currVersions = currVersions || {en: null, he: null};
if (!ref) { return Promise.reject(new Error("No Ref!")); }
-
- const r = this.getRefFromCache(ref);
- if (r) return Promise.resolve(r);
-
- // To avoid an extra API call, first look for any open API calls to this ref (regardless of params)
- // todo: Ugly. Breaks abstraction.
- const urlPattern = "/api/texts/" + this.normRef(ref);
- const openApiCalls = Object.keys(this._ajaxObjects);
- for (let i = 0; i < openApiCalls.length; i++) {
- if (openApiCalls[i].startsWith(urlPattern)) {
- return this._ajaxObjects[openApiCalls[i]];
- }
- }
-
- // If no open calls found, call the texts API.
- // Called with context:1 because this is our most common mode, maximize change of saving an API Call
- return Sefaria.getText(ref, {context: 1});
+ return Sefaria.getTextFromCurrVersions(ref, currVersions);
},
ref: function(ref, callback) {
if (callback) {
@@ -2212,8 +2300,8 @@ _media: {},
sectionString: function(ref) {
// Returns a pair of nice strings (en, he) of the sections indicated in ref. e.g.,
// "Genesis 4" -> "Chapter 4", "Guide for the Perplexed, Introduction" - > "Introduction"
- var data = this.getRefFromCache(ref);
- var result = {
+ const data = this.getRefFromCache(ref);
+ let result = {
en: {named: "", numbered: ""},
he: {named: "", numbered: ""}
};
@@ -2237,7 +2325,7 @@ _media: {},
result.en.numbered = sections;
// Hebrew
- var sections = data.heRef.slice(data.heIndexTitle.length+1);
+ var sections = data.heSectionRef.slice(data.heIndexTitle.length+1);
var name = ""; // missing he section names // data.sectionNames.length > 1 ? " " + data.sectionNames[0] : "";
if (data.isComplex) {
var numberedSections = data.heRef.slice(data.heTitle.length+1);
@@ -2424,7 +2512,7 @@ _media: {},
},
areVersionsEqual(v1, v2) {
// v1, v2 are `currVersions` objects stored like {en: ven, he: vhe}
- return v1.en == v2.en && v1.he == v2.he;
+ return v1?.en === v2?.en && v1?.he === v2?.he;
},
getSavedItem: ({ ref, versions }) => {
return Sefaria.saved.items.find(s => s.ref === ref && Sefaria.areVersionsEqual(s.versions, versions));
@@ -3251,7 +3339,7 @@ Sefaria.unpackDataFromProps = function(props) {
let settings = {context: 1, enVersion: panel.enVersion, heVersion: panel.heVersion};
//save versions first, so their new format is also saved on text cache
if(panel.text?.versions?.length){
- let versions = Sefaria._saveVersions(panel.text.sectionRef, panel.text.versions);
+ let versions = Sefaria.saveVersions(panel.text.sectionRef, panel.text.available_versions);
panel.text.versions = Sefaria._makeVersions(versions, false);
}
@@ -3259,7 +3347,7 @@ Sefaria.unpackDataFromProps = function(props) {
}
if(panel.bookRef){
if(panel.versions?.length){
- let versions = Sefaria._saveVersions(panel.bookRef, panel.versions);
+ let versions = Sefaria.saveVersions(panel.bookRef, panel.versions);
panel.versions = Sefaria._makeVersions(versions, false);
}
}
diff --git a/static/js/sefaria/strings.js b/static/js/sefaria/strings.js
index e99b29c75f..b7a94c3b68 100644
--- a/static/js/sefaria/strings.js
+++ b/static/js/sefaria/strings.js
@@ -404,12 +404,14 @@ const Strings = {
"Hide Parasha Aliyot": "עליות לתורה מוסתרות",
"Language": "שפה",
"Layout": "עימוד",
- "Bilingual Layout" : "עימוד דו לשוני",
+ "Translation": "תרגום",
+ 'Source with Translation': 'מקור ותרגום',
"Color": "צבע",
"Font Size" : "גודל גופן",
"Aliyot" : "עליות לתורה",
"Taamim and Nikkud" : "טעמים וניקוד",
"Punctuation" : "פיסוק",
+ 'Cantilation': 'טעמים',
"Show Punctuation": "הצגת סימני פיסוק",
"Hide Punctuation": "הסתרת סימני פיסוק",
"Show Vowels and Cantillation": "הצג טקסט עם טעמי מקרא וניקוד",
diff --git a/static/js/sefaria/textCache.js b/static/js/sefaria/textCache.js
new file mode 100644
index 0000000000..8d054a54cd
--- /dev/null
+++ b/static/js/sefaria/textCache.js
@@ -0,0 +1,202 @@
+// this module is for saving text cache
+// its interface, TextCache, gets api response and stores it.
+// its getter gets ref, language and versionTitle and returns a response-like object (for only one version)
+// for saving memory there are different objects for storing general data of books, versions and sections
+// the text itself stored in the segment level
+// the principle of the structure is that setting and getting will be done by keys, so the extraction will be quick
+
+import Sefaria from "./sefaria";
+
+const BOOK_ATTRS = new Set(['primary_category', 'type', 'indexTitle', 'categories', 'heIndexTitle', 'isComplex',
+ 'isDependant', 'order', 'collectiveTitle', 'heCollectiveTitle']);
+const SECTION_ATTRS = new Set(['sectionRef', 'heSectionRef', 'next', 'prev', 'title', 'book', 'lengths', 'length',
+ 'textDepth', 'sectionNames', 'addressTypes', 'heTitle', 'titleVariants', 'heTitleVariants', 'index_offsets_by_depth',
+ 'isSpanning', 'spanningRefs', 'alts', 'firstAvailableSectionRef', 'indexTitle']);
+const REF_ATTRS = new Set(['ref', 'heRef', 'sections', 'toSections', 'sectionRef']);
+
+
+class BookAndVersionsDetails {
+ // this class is an object that stores the book details and its versions details
+ constructor() {
+ this.versions = {}
+ this.general = {}
+ }
+ set(response) {
+ BOOK_ATTRS.forEach((attr) => {
+ this.general[attr] = response[attr];
+ })
+ response.versions.forEach((version) => {
+ const {actualLanguage, versionTitle} = { ...version };
+ if (!this.versions[actualLanguage]) {
+ this.versions[actualLanguage] = {};
+ }
+ this.versions[actualLanguage][versionTitle] = { ...version };
+ delete this.versions[actualLanguage][versionTitle].text;
+ })
+ }
+ get(language, versionTitle) {
+ let version = { ...this.versions[language]?.[versionTitle] };
+ if (Object.keys(version).length) {
+ return {
+ versions: [version],
+ ...this.general
+ };
+ }
+ }
+}
+
+
+class Ref {
+ // this class is the father of Section and Segment. it handles the data about the ref
+ constructor() {
+ this.refAttrs = {};
+ }
+ set(refAttrs) {
+ REF_ATTRS.forEach((attr) => {
+ this.refAttrs[attr] = refAttrs[attr];
+ })
+ }
+ get_text() {
+ }
+ get(language, versionTitle) {
+ const text = this.get_text(language, versionTitle);
+ if (text) {
+ return {
+ refAttrs: this.refAttrs,
+ text: text
+ };
+ }
+ }
+}
+
+
+class Segment extends Ref {
+ // this class is an object stores Segment text
+ // it is an object of languages, with an object of versionTitles for each language
+ constructor() {
+ super();
+ this.texts = {};
+ }
+ _addLangIfMissing(language) {
+ if (!(language in this.texts)) {
+ this.texts[language] = {};
+ }
+ }
+ set(language, versionTitle, refAttrs, text) {
+ super.set(refAttrs)
+ this._addLangIfMissing(language);
+ this.texts[language][versionTitle] = text;
+ }
+ get_text(language, versionTitle) {
+ return this.texts[language]?.[versionTitle];
+ }
+}
+
+
+class Section extends Ref {
+ // this class is object that stores section - its segment attribute is array of Segments
+ constructor() {
+ super();
+ this.segments = [];
+ }
+ set(refAttrs, segmentObjects) {
+ super.set(refAttrs);
+ this.segments = segmentObjects;
+ }
+ get_text(language, versionTitle) {
+ const segmenets = this.segments.map((segment) => {
+ return segment.get_text(language, versionTitle);
+ })
+ // check that no element in array is undefined
+ if (segmenets.every((segment) => segment !== undefined)) {
+ return segmenets;
+ }
+ }
+}
+
+
+class TextCache {
+ // this is the interface
+ // its setter gets the response, and the getter gets ref, language and versionTitle, and returns a response-like object with one version
+ constructor() {
+ this.refs = {};
+ this.books = {};
+ this.sectionsAttrs = {};
+ }
+ _setBookDetails(title, response) {
+ if (!this.books[title]) {
+ this.books[title] = new BookAndVersionsDetails();
+ }
+ this.books[title].set(response);
+ }
+ _setSectionAttrs(sectionRef, response) {
+ this.sectionsAttrs[sectionRef] = {};
+ SECTION_ATTRS.forEach((attr) => {
+ this.sectionsAttrs[sectionRef][attr] = response[attr];
+ })
+ }
+ _createNew(ref, className) {
+ if (!(ref in this.refs)) {
+ this.refs[ref] = new className();
+ }
+ }
+ _setSegment(ref, language, versionTitle, response, text) {
+ this._createNew(ref, Segment)
+ this.refs[ref].set(language, versionTitle, response, text);
+ }
+ _setSection(ref, language, versionTitle, response, text) {
+ this._createNew(ref, Section)
+ const offset = Sefaria._get_offsets(response);
+ const start = 1 + offset[0];
+ const segments = [];
+ text.forEach((segmentText, i) => {
+ const segmentNum = start + i;
+ const segmentRef = `${ref}:${segmentNum}`;
+ const refAttrs = {
+ ref: segmentRef,
+ heRef: `${response.heRef}:${Sefaria.hebrew.encodeHebrewNumeral(segmentNum)}`,
+ sections: response.sections.concat(i+1),
+ toSections: response.sections.concat(i+1),
+ sectionRef: ref
+ };
+ this._setSegment(segmentRef, language, versionTitle, refAttrs, segmentText);
+ segments.push(this.refs[segmentRef])
+ })
+ this.refs[ref].set(response, segments)
+ }
+ set(response) {
+ // the response should be for segment ref or bottom level section ref (not above, and not ranged)
+ const {indexTitle, ref, sectionRef} = { ...response };
+ this._setBookDetails(indexTitle, response);
+ this._setSectionAttrs(sectionRef, response);
+ const isSectionLevel = ref === sectionRef;
+ response.versions.forEach((version) => {
+ const {actualLanguage, versionTitle} = { ...version };
+ if (isSectionLevel) {
+ this._setSection(ref, actualLanguage, versionTitle, response, version.text);
+ } else {
+ this._setSegment(ref, actualLanguage, versionTitle, response, version.text);
+ }
+ })
+ }
+ get(ref, language, versionTitle) {
+ const textObject = this.refs[ref]?.get(language, versionTitle);
+ if (textObject) {
+ const sectionAttrs = this.sectionsAttrs[textObject.refAttrs.sectionRef];
+ const book = this.books[sectionAttrs.indexTitle].get(language, versionTitle);
+ if (book) {
+ const returnObj = {
+ ...this.books[sectionAttrs.indexTitle].get(language, versionTitle),
+ ...sectionAttrs,
+ ...textObject.refAttrs
+ };
+ returnObj.versions[0].text = textObject.text;
+ return returnObj;
+ }
+ }
+ }
+}
+
+
+const CACHE = new TextCache();
+export default CACHE;
diff --git a/static/js/sefaria/util.js b/static/js/sefaria/util.js
index 31c5406d80..4d32999688 100644
--- a/static/js/sefaria/util.js
+++ b/static/js/sefaria/util.js
@@ -48,30 +48,22 @@ class Util {
static encodeVtitle(vtitle) {
return vtitle.replace(/\s/g, '_').replace(/;/g, '%3B');
}
+ static _getVersionParams(version) {
+ return `${version.languageFamilyName}|${this.encodeVtitle(version.versionTitle)}`;
+ }
static getUrlVersionsParams(currVersions, i=0) {
- currVersions = this.getCurrVersionsWithoutAPIResultFields(currVersions);
if (currVersions) {
return Object.entries(currVersions)
- .filter(([vlang, vtitle]) => !!vtitle)
- .map(([vlang, vtitle]) =>`&v${vlang}${i > 1 ? i : ""}=${this.encodeVtitle(vtitle)}`)
+ .filter(([vlang, version]) => !!version?.versionTitle)
+ .map(([vlang, version]) =>`&v${vlang}${i > 1 ? i : ""}=${this._getVersionParams(version)}`)
.join("");
} else {
return "";
}
}
- static getCurrVersionsWithoutAPIResultFields(currVersions) {
- /**
- * currVersions can contain fields like `enAPIResult` and `heAPIResult`.
- * returns an object without these fields
- */
- if (!currVersions) { return currVersions; }
- return Object.entries(currVersions).reduce(
- (a, [vlang, vtitle]) => {
- if (vlang.endsWith("APIResult")) { return a; }
- a[vlang] = vtitle;
- return a;
- }, {}
- );
+ static getObjectFromUrlParam(param) {
+ const params = (params) ? param.split('|') : '';
+ return {languageFamilyName: params[0], versionTitle: params[1]};
}
static decodeVtitle(vtitle) {
return vtitle.replace(/_/g, ' ').replace(/%3B/g, ';');
}