/**
* Translates a text string from one language to another.
* @method getTranslationAsync
* @param {string} text
* Required. A string representing the text to translate. The size of the text must not exceed 10000 characters.
* @param {string} from
* Optional. A string representing the language code of the translation text. For example, en for English.
* @param {string} to
* Optional. A string representing the language code to translate the text into.
* @returns {string}
* A string representing the translated text.
*/
public async getTranslationAsync(text: string, from?: string, to: string = "en"): Promise<string | undefined> {
let translatorApiKey = process.env.COGNITIVE_TRANSLATOR_API_KEY;
if (!translatorApiKey) {
throw new Error('translator text api key is undefined')
}
if (!text) {
throw new Error('text argument is empty or undefined')
}
let encodedText = encodeURIComponent(text);
let url = `${baseUrl}/Translate?text=${encodedText}`;
if (from) {
url += `&from=${from}`;
}
if (to) {
url += `&to=${to}`
}
let response = await fetch(url,
{
method: 'GET',
headers:
{
'Ocp-Apim-Subscription-Key': translatorApiKey,
}
})
.catch(error => console.error(error));
if (response && response.status && response.status >= 200 && response.status <= 299) {
let xmlcontent = await response.text()
if (xmlcontent) {
let json = xmljs.xml2js(xmlcontent, { compact: true, ignoreAttributes: true });
if (json && json.string && json.string._text) {
return json.string._text;
}
}
}
return undefined;
}
private extractDocumentRefs(xmlData: string): IDocumentRefs {
const xmlObj = xml2js(xmlData, { compact: true }) as XMLElementCompact;
const sectionProp = xmlObj["w:document"]["w:body"]["w:sectPr"];
const headerProps: XMLElementCompact = sectionProp["w:headerReference"];
let headersXmlArray: XMLElementCompact[];
if (headerProps === undefined) {
headersXmlArray = [];
} else if (Array.isArray(headerProps)) {
headersXmlArray = headerProps;
} else {
headersXmlArray = [headerProps];
}
const headers = headersXmlArray.map((item) => {
if (item._attributes === undefined) {
throw Error("header referecne element has no attributes");
}
return {
type: item._attributes["w:type"] as HeaderReferenceType,
id: this.parseRefId(item._attributes["r:id"] as string),
};
});
const footerProps: XMLElementCompact = sectionProp["w:footerReference"];
let footersXmlArray: XMLElementCompact[];
if (footerProps === undefined) {
footersXmlArray = [];
} else if (Array.isArray(footerProps)) {
footersXmlArray = footerProps;
} else {
footersXmlArray = [footerProps];
}
const footers = footersXmlArray.map((item) => {
if (item._attributes === undefined) {
throw Error("footer referecne element has no attributes");
}
return {
type: item._attributes["w:type"] as FooterReferenceType,
id: this.parseRefId(item._attributes["r:id"] as string),
};
});
return { headers, footers };
}
/**
* Retrieves friendly names for the languages passed in as the parameter languageCode,
* and localized using the passed locale language.
* @method getLanguageNameAsync
* @param {string} languageCode
* Required. A string representing the ISO 639-1 language code to retrieve the friendly names for.
* @param {string} locale
* Optional. A string representing a combination of an ISO 639 two-letter lowercase culture code
* associated with a language and an ISO 3166 two-letter uppercase subculture code to localize the language names or a ISO 639 lowercase culture code by itself.
* @returns {string}
* A string representing the translated text.
*/
public async getLanguageNameAsync(languageCode: string, locale: string = "en"): Promise<string | undefined> {
let code = encodeURIComponent(languageCode);
let translatorApiKey = process.env.COGNITIVE_TRANSLATOR_API_KEY;
// Check if environment variables are correct
if (translatorApiKey == undefined) {
console.log("Cognitive Services - Translation - Url or Api Key undefined.");
return undefined;
}
let query = `${baseUrl}/GetLanguageNames?locale=${locale}`;
let response = await fetch(query,
{
method: 'POST',
headers:
{
'Ocp-Apim-Subscription-Key': translatorApiKey,
'Content-Type': 'text/xml'
},
body:
`<ArrayOfstring xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
<string>${languageCode}</string>
</ArrayOfstring>`
})
.catch(error => console.error(error));
if (response && response.status && response.status >= 200 && response.status <= 299) {
let xmlcontent = await response.text()
if (xmlcontent) {
let json = xmljs.xml2js(xmlcontent, { compact: true, ignoreAttributes: true });
if (json && json.ArrayOfstring && json.ArrayOfstring.string && json.ArrayOfstring.string._text) {
return json.ArrayOfstring.string._text;
}
}
}
return undefined;
}
private findReferenceFiles(xmlData: string): IRelationshipFileInfo[] {
const xmlObj = xml2js(xmlData, { compact: true }) as XMLElementCompact;
const relationXmlArray = Array.isArray(xmlObj.Relationships.Relationship)
? xmlObj.Relationships.Relationship
: [xmlObj.Relationships.Relationship];
const relationships: IRelationshipFileInfo[] = relationXmlArray
.map((item: XMLElementCompact) => {
if (item._attributes === undefined) {
throw Error("relationship element has no attributes");
}
return {
id: this.parseRefId(item._attributes.Id as string),
type: schemeToType[item._attributes.Type as string],
target: item._attributes.Target as string,
};
})
.filter((item) => item.type !== null);
return relationships;
}
/**
* Creates new Style based on the given styles.
* Parses the styles and convert them to XmlComponent.
* Example content from styles.xml:
* <?xml version="1.0">
* <w:styles xmlns:mc="some schema" ...>
*
* <w:style w:type="paragraph" w:styleId="Heading1">
* <w:name w:val="heading 1"/>
* .....
* </w:style>
*
* <w:style w:type="paragraph" w:styleId="Heading2">
* <w:name w:val="heading 2"/>
* .....
* </w:style>
*
* <w:docDefaults>Or any other element will be parsed to</w:docDefaults>
*
* </w:styles>
* @param externalStyles context from styles.xml
*/
public newInstance(xmlData: string): Styles {
const xmlObj = xml2js(xmlData, { compact: false }) as XMLElement;
let stylesXmlElement: XMLElement | undefined;
for (const xmlElm of xmlObj.elements || []) {
if (xmlElm.name === "w:styles") {
stylesXmlElement = xmlElm;
}
}
if (stylesXmlElement === undefined) {
throw new Error("can not find styles element");
}
const importedStyle = new Styles(new ImportedRootElementAttributes(stylesXmlElement.attributes));
const stylesElements = stylesXmlElement.elements || [];
for (const childElm of stylesElements) {
importedStyle.push(convertToXmlComponent(childElm) as ImportedXmlComponent);
}
return importedStyle;
}
.map(async (reference, i) => {
const relationshipFileInfo = documentRelationships.find((rel) => rel.id === reference.id);
if (relationshipFileInfo === null || !relationshipFileInfo) {
throw new Error(`Can not find target file for id ${reference.id}`);
}
const xmlData = await zipContent.files[`word/${relationshipFileInfo.target}`].async("text");
const xmlObj = xml2js(xmlData, { compact: false, captureSpacesBetweenElements: true }) as XMLElement;
if (!xmlObj.elements) {
return undefined;
}
const xmlElement = xmlObj.elements.reduce((acc, current) => (current.name === "w:ftr" ? current : acc));
const importedComp = convertToXmlComponent(xmlElement) as ImportedXmlComponent;
const wrapper = new FooterWrapper(media, startingRelationshipId + i, importedComp);
await this.addRelationshipToWrapper(relationshipFileInfo, zipContent, wrapper, media);
return { type: reference.type, footer: wrapper };
})
private checkIfTitlePageIsDefined(xmlData: string): boolean {
const xmlObj = xml2js(xmlData, { compact: true }) as XMLElementCompact;
const sectionProp = xmlObj["w:document"]["w:body"]["w:sectPr"];
return sectionProp["w:titlePg"] !== undefined;
}
/**
* Converts the xml string to a XmlComponent tree.
*
* @param importedContent xml content of the imported component
*/
public static fromXmlString(importedContent: string): ImportedXmlComponent {
const xmlObj = xml2js(importedContent, { compact: false }) as XmlElement;
return convertToXmlComponent(xmlObj) as ImportedXmlComponent;
}
it("should convert to xml component", () => {
const xmlObj = xml2js(xmlString, { compact: false }) as Element;
const converted = convertToXmlComponent(xmlObj);
expect(converted).to.deep.equal(convertedXmlElement);
});
export const xmlToTreeNode = memoize((xml: string): TreeNode => {
return normalizeTree(xml2js(xml).elements[0]);
});