Skip to content

Commit

Permalink
Resolved styleObj issue for TS error no-shadowed-variable
Browse files Browse the repository at this point in the history
  • Loading branch information
Netraj Patel committed Jan 8, 2024
1 parent 386a271 commit 0f3ef25
Show file tree
Hide file tree
Showing 2 changed files with 165 additions and 160 deletions.
82 changes: 41 additions & 41 deletions src/Models/metadata-model.ts
View file
Original file line number Diff line number Diff line change
@@ -1,24 +1,24 @@
import StyleType from '../embedded-types/style-type';
import TextNode from '../nodes/text-node';
export interface Metadata {
text: string
attributes: Attributes
text: string;
attributes: Attributes;

itemUid: string | undefined
itemType: 'entry' | 'asset' | undefined
styleType: StyleType | undefined
contentTypeUid: string | undefined
itemUid: string | undefined;
itemType: 'entry' | 'asset' | undefined;
styleType: StyleType | undefined;
contentTypeUid: string | undefined;
}

export interface Attributes {
type?: 'entry' | 'asset',
class?: string,
id?: string,
[key: string]: any,
style?: styleObj | string,
'sys-style-type'?: string,
type?: 'entry' | 'asset';
class?: string;
id?: string;
[key: string]: any;
style?: styleObjType | string;
'sys-style-type'?: string;
}
export type styleObj = { [key: string]: any }
export type styleObjType = { [key: string]: any };

export interface EntryAttributes extends Attributes {
'data-sys-entry-uid': string;
Expand All @@ -35,54 +35,54 @@ export interface AssetAttributes extends Attributes {
export function createMetadata(attribute: Attributes): Metadata {
return {
text: attribute['#text'],
itemUid: attribute["data-sys-entry-uid"] || attribute["data-sys-asset-uid"],
itemUid: attribute['data-sys-entry-uid'] || attribute['data-sys-asset-uid'],
itemType: attribute.type,
styleType: attribute["sys-style-type"] as StyleType,
styleType: attribute['sys-style-type'] as StyleType,
attributes: attribute,
contentTypeUid: attribute["data-sys-content-type-uid"],
}
contentTypeUid: attribute['data-sys-content-type-uid'],
};
}

export function nodeToMetadata(attribute: Attributes, textNode: TextNode): Metadata {
return {
text: textNode.text,
itemUid: attribute["entry-uid"] || attribute["asset-uid"],
itemType: attribute.type,
styleType: attribute["display-type"] as StyleType,
attributes: attribute,
contentTypeUid: attribute["content-type-uid"],
}
return {
text: textNode.text,
itemUid: attribute['entry-uid'] || attribute['asset-uid'],
itemType: attribute.type,
styleType: attribute['display-type'] as StyleType,
attributes: attribute,
contentTypeUid: attribute['content-type-uid'],
};
}

export function attributeToString( attributes: Attributes):string {
let result = ''
export function attributeToString(attributes: Attributes): string {
let result = '';
for (const key in attributes) {
if (Object.prototype.hasOwnProperty.call(attributes, key)) {
let element = attributes[key];
if (element instanceof Array) {
let elementString = ''
let isFirst = true
let elementString = '';
let isFirst = true;
element.forEach((value) => {
if (isFirst) {
elementString += `${value}`
isFirst = false
}else {
elementString += `, ${value}`
elementString += `${value}`;
isFirst = false;
} else {
elementString += `, ${value}`;
}
})
element = elementString
});
element = elementString;
} else if (typeof element === 'object') {
let elementString = ''
let elementString = '';
for (const elementKey in element) {
if (Object.prototype.hasOwnProperty.call(element, elementKey)) {
const value = element[elementKey];
elementString += `${elementKey}:${value}; `
elementString += `${elementKey}:${value}; `;
}
}
element = elementString
element = elementString;
}
result += ` ${key}="${element}"`
result += ` ${key}="${element}"`;
}
}
return result
}
return result;
}
243 changes: 124 additions & 119 deletions src/helper/enumerate-entries.ts
View file
Original file line number Diff line number Diff line change
@@ -1,138 +1,143 @@
import { AnyNode } from "../json-to-html";
import { EmbeddedItem, EntryEmbedable } from "../Models/embedded-object";
import { Metadata, nodeToMetadata, styleObj } from "../Models/metadata-model";
import MarkType from "../nodes/mark-type";
import TextNode from "../nodes/text-node";
import Node from '../nodes/node'
import Document from '../nodes/document'
import { Next, RenderMark, RenderNode, RenderOption } from "../options";
import { defaultNodeOption } from "../options/default-node-options";
import { findRenderString } from "./find-embeded-object";
import { EntryNode } from "../Models/json-rte-model";
import { AnyNode } from '../json-to-html';
import { EmbeddedItem, EntryEmbedable } from '../Models/embedded-object';
import { Metadata, nodeToMetadata, styleObjType } from '../Models/metadata-model';
import MarkType from '../nodes/mark-type';
import TextNode from '../nodes/text-node';
import Node from '../nodes/node';
import Document from '../nodes/document';
import { Next, RenderMark, RenderNode, RenderOption } from '../options';
import { defaultNodeOption } from '../options/default-node-options';
import { findRenderString } from './find-embeded-object';
import { EntryNode } from '../Models/json-rte-model';

export function enumerate(
entries: EntryEmbedable[] | EmbeddedItem[],
process: (entry: EntryEmbedable| EmbeddedItem) => void
) {
for (const entry of entries) {
process(entry)
}
export function enumerate(
entries: EntryEmbedable[] | EmbeddedItem[],
process: (entry: EntryEmbedable | EmbeddedItem) => void,
) {
for (const entry of entries) {
process(entry);
}
}

export function enumerateContents(
content:Document | Document[],
renderOption?: RenderOption,
renderEmbed?: (metadata: Metadata) => EmbeddedItem| EntryNode
content: Document | Document[],
renderOption?: RenderOption,
renderEmbed?: (metadata: Metadata) => EmbeddedItem | EntryNode,
): string | string[] {
if (!(content instanceof Array) && content.type !== 'doc') {
return content as unknown as string
}
if (content instanceof Array) {
const result: string[] = []
content.forEach((doc) => {
result.push(enumerateContents(doc, renderOption, renderEmbed) as string)
})
return result
}
const commonRenderOption = {
...defaultNodeOption,
...renderOption
}
return nodeChildrenToHTML(content.children, commonRenderOption, renderEmbed)
if (!(content instanceof Array) && content.type !== 'doc') {
return content as unknown as string;
}
if (content instanceof Array) {
const result: string[] = [];
content.forEach((doc) => {
result.push(enumerateContents(doc, renderOption, renderEmbed) as string);
});
return result;
}
const commonRenderOption = {
...defaultNodeOption,
...renderOption,
};
return nodeChildrenToHTML(content.children, commonRenderOption, renderEmbed);
}

export function textNodeToHTML(node: TextNode, renderOption: RenderOption): string {
let text = node.text
if (node.classname || node.id) {
text = (renderOption[MarkType.CLASSNAME_OR_ID] as RenderMark)(text, node.classname, node.id)
}
if (node.break) {
text = (renderOption[MarkType.BREAK] as RenderMark)(text)
}
if (node.superscript) {
text = (renderOption[MarkType.SUPERSCRIPT] as RenderMark)(text)
}
if (node.subscript) {
text = (renderOption[MarkType.SUBSCRIPT] as RenderMark)(text)
}
if (node.inlineCode) {
text = (renderOption[MarkType.INLINE_CODE] as RenderMark)(text)
}
if (node.strikethrough) {
text = (renderOption[MarkType.STRIKE_THROUGH] as RenderMark)(text)
}
if (node.underline) {
text = (renderOption[MarkType.UNDERLINE] as RenderMark)(text)
}
if (node.italic) {
text = (renderOption[MarkType.ITALIC] as RenderMark)(text)
}
if (node.bold) {
text = (renderOption[MarkType.BOLD] as RenderMark)(text)
}
return text
let text = node.text;
if (node.classname || node.id) {
text = (renderOption[MarkType.CLASSNAME_OR_ID] as RenderMark)(text, node.classname, node.id);
}
if (node.break) {
text = (renderOption[MarkType.BREAK] as RenderMark)(text);
}
if (node.superscript) {
text = (renderOption[MarkType.SUPERSCRIPT] as RenderMark)(text);
}
if (node.subscript) {
text = (renderOption[MarkType.SUBSCRIPT] as RenderMark)(text);
}
if (node.inlineCode) {
text = (renderOption[MarkType.INLINE_CODE] as RenderMark)(text);
}
if (node.strikethrough) {
text = (renderOption[MarkType.STRIKE_THROUGH] as RenderMark)(text);
}
if (node.underline) {
text = (renderOption[MarkType.UNDERLINE] as RenderMark)(text);
}
if (node.italic) {
text = (renderOption[MarkType.ITALIC] as RenderMark)(text);
}
if (node.bold) {
text = (renderOption[MarkType.BOLD] as RenderMark)(text);
}
return text;
}
export function referenceToHTML(node: Node,
renderOption: RenderOption,
renderEmbed?: (metadata: Metadata) => EmbeddedItem | EntryNode
export function referenceToHTML(
node: Node,
renderOption: RenderOption,
renderEmbed?: (metadata: Metadata) => EmbeddedItem | EntryNode,
): string {
function sendToRenderOption(referenceNode: Node): string {
return (renderOption[referenceNode.type] as RenderNode)(referenceNode, undefined)
}
if (!renderEmbed && renderOption[node.type] !== undefined) {
return sendToRenderOption(node)
}
if (!renderEmbed) {
return ''
}
const metadata = nodeToMetadata(node.attrs, ((node.children && node.children.length > 0) ? node.children[0]: {}) as unknown as TextNode)
const item = renderEmbed(metadata)
if (!item && renderOption[node.type] !== undefined) {
return sendToRenderOption(node)
}
return findRenderString(item, metadata, renderOption)
function sendToRenderOption(referenceNode: Node): string {
return (renderOption[referenceNode.type] as RenderNode)(referenceNode, undefined);
}
if (!renderEmbed && renderOption[node.type] !== undefined) {
return sendToRenderOption(node);
}
if (!renderEmbed) {
return '';
}
const metadata = nodeToMetadata(
node.attrs,
(node.children && node.children.length > 0 ? node.children[0] : {}) as unknown as TextNode,
);
const item = renderEmbed(metadata);
if (!item && renderOption[node.type] !== undefined) {
return sendToRenderOption(node);
}
return findRenderString(item, metadata, renderOption);
}

function nodeChildrenToHTML(nodes: AnyNode[],
renderOption: RenderOption,
renderEmbed?: (metadata: Metadata) => EmbeddedItem | EntryNode,
): string {
return nodes.map<string>((node: AnyNode) => nodeToHTML(node, renderOption, renderEmbed)).join('')
function nodeChildrenToHTML(
nodes: AnyNode[],
renderOption: RenderOption,
renderEmbed?: (metadata: Metadata) => EmbeddedItem | EntryNode,
): string {
return nodes.map<string>((node: AnyNode) => nodeToHTML(node, renderOption, renderEmbed)).join('');
}

function styleObjectToString(styleObj: styleObj): string {
if (!styleObj) return '';
if (typeof styleObj === 'string') {
return styleObj;
}
let styleString: string = '';
for (const key in styleObj) {
if (styleObj.hasOwnProperty(key)) {
const value = styleObj[key];
styleString += `${key}:${value};`;
}
}
return styleString;
function styleObjectToString(styleObj: styleObjType): string {
if (!styleObj) return '';
if (typeof styleObj === 'string') {
return styleObj;
}
let styleString: string = '';
for (const key in styleObj) {
if (styleObj.hasOwnProperty(key)) {
const value = styleObj[key];
styleString += `${key}:${value};`;
}
}
return styleString;
}

function nodeToHTML(
node: AnyNode,
renderOption: RenderOption,
renderEmbed?: (metadata: Metadata) => EmbeddedItem | EntryNode,
node: AnyNode,
renderOption: RenderOption,
renderEmbed?: (metadata: Metadata) => EmbeddedItem | EntryNode,
): string {
if (node?.attrs?.style){
node.attrs.style = styleObjectToString(node.attrs.style as styleObj)
}
if (!node.type) {
return textNodeToHTML(node as TextNode, renderOption)
}else if ((node.type as string) === 'reference') {
return referenceToHTML(node, renderOption, renderEmbed)
}else {
const next: Next = nodes => nodeChildrenToHTML(nodes, renderOption, renderEmbed)
if (renderOption[node.type] !== undefined) {
return (renderOption[node.type] as RenderNode)(node, next)
}else {
return (renderOption.default as RenderNode)(node, next)
}
}
if (node?.attrs?.style) {
node.attrs.style = styleObjectToString(node.attrs.style as styleObjType);
}
if (!node.type) {
return textNodeToHTML(node as TextNode, renderOption);
} else if ((node.type as string) === 'reference') {
return referenceToHTML(node, renderOption, renderEmbed);
} else {
const next: Next = (nodes) => nodeChildrenToHTML(nodes, renderOption, renderEmbed);
if (renderOption[node.type] !== undefined) {
return (renderOption[node.type] as RenderNode)(node, next);
} else {
return (renderOption.default as RenderNode)(node, next);
}
}
}

0 comments on commit 0f3ef25

Please sign in to comment.