mirror of
https://gitee.com/onvia/ccc-tnt-psd2ui
synced 2024-12-26 11:48:25 +00:00
554 lines
22 KiB
JavaScript
554 lines
22 KiB
JavaScript
var __assign = (this && this.__assign) || function () {
|
|
__assign = Object.assign || function(t) {
|
|
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
|
s = arguments[i];
|
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
|
|
t[p] = s[p];
|
|
}
|
|
return t;
|
|
};
|
|
return __assign.apply(this, arguments);
|
|
};
|
|
var defaultFont = {
|
|
name: 'MyriadPro-Regular',
|
|
script: 0,
|
|
type: 0,
|
|
synthetic: 0,
|
|
};
|
|
var defaultParagraphStyle = {
|
|
justification: 'left',
|
|
firstLineIndent: 0,
|
|
startIndent: 0,
|
|
endIndent: 0,
|
|
spaceBefore: 0,
|
|
spaceAfter: 0,
|
|
autoHyphenate: true,
|
|
hyphenatedWordSize: 6,
|
|
preHyphen: 2,
|
|
postHyphen: 2,
|
|
consecutiveHyphens: 8,
|
|
zone: 36,
|
|
wordSpacing: [0.8, 1, 1.33],
|
|
letterSpacing: [0, 0, 0],
|
|
glyphSpacing: [1, 1, 1],
|
|
autoLeading: 1.2,
|
|
leadingType: 0,
|
|
hanging: false,
|
|
burasagari: false,
|
|
kinsokuOrder: 0,
|
|
everyLineComposer: false,
|
|
};
|
|
var defaultStyle = {
|
|
font: defaultFont,
|
|
fontSize: 12,
|
|
fauxBold: false,
|
|
fauxItalic: false,
|
|
autoLeading: true,
|
|
leading: 0,
|
|
horizontalScale: 1,
|
|
verticalScale: 1,
|
|
tracking: 0,
|
|
autoKerning: true,
|
|
kerning: 0,
|
|
baselineShift: 0,
|
|
fontCaps: 0,
|
|
fontBaseline: 0,
|
|
underline: false,
|
|
strikethrough: false,
|
|
ligatures: true,
|
|
dLigatures: false,
|
|
baselineDirection: 2,
|
|
tsume: 0,
|
|
styleRunAlignment: 2,
|
|
language: 0,
|
|
noBreak: false,
|
|
fillColor: { r: 0, g: 0, b: 0 },
|
|
strokeColor: { r: 0, g: 0, b: 0 },
|
|
fillFlag: true,
|
|
strokeFlag: false,
|
|
fillFirst: true,
|
|
yUnderline: 1,
|
|
outlineWidth: 1,
|
|
characterDirection: 0,
|
|
hindiNumbers: false,
|
|
kashida: 1,
|
|
diacriticPos: 2,
|
|
};
|
|
var defaultGridInfo = {
|
|
isOn: false,
|
|
show: false,
|
|
size: 18,
|
|
leading: 22,
|
|
color: { r: 0, g: 0, b: 255 },
|
|
leadingFillColor: { r: 0, g: 0, b: 255 },
|
|
alignLineHeightToGridFlags: false,
|
|
};
|
|
var paragraphStyleKeys = [
|
|
'justification', 'firstLineIndent', 'startIndent', 'endIndent', 'spaceBefore', 'spaceAfter',
|
|
'autoHyphenate', 'hyphenatedWordSize', 'preHyphen', 'postHyphen', 'consecutiveHyphens',
|
|
'zone', 'wordSpacing', 'letterSpacing', 'glyphSpacing', 'autoLeading', 'leadingType',
|
|
'hanging', 'burasagari', 'kinsokuOrder', 'everyLineComposer',
|
|
];
|
|
var styleKeys = [
|
|
'font', 'fontSize', 'fauxBold', 'fauxItalic', 'autoLeading', 'leading', 'horizontalScale',
|
|
'verticalScale', 'tracking', 'autoKerning', 'kerning', 'baselineShift', 'fontCaps', 'fontBaseline',
|
|
'underline', 'strikethrough', 'ligatures', 'dLigatures', 'baselineDirection', 'tsume',
|
|
'styleRunAlignment', 'language', 'noBreak', 'fillColor', 'strokeColor', 'fillFlag',
|
|
'strokeFlag', 'fillFirst', 'yUnderline', 'outlineWidth', 'characterDirection', 'hindiNumbers',
|
|
'kashida', 'diacriticPos',
|
|
];
|
|
var antialias = ['none', 'crisp', 'strong', 'smooth', 'sharp'];
|
|
var justification = ['left', 'right', 'center'];
|
|
function upperFirst(value) {
|
|
return value.substr(0, 1).toUpperCase() + value.substr(1);
|
|
}
|
|
function decodeColor(color) {
|
|
var c = color.Values;
|
|
if (color.Type === 0) { // grayscale
|
|
return { r: c[1] * 255, g: c[1] * 255, b: c[1] * 255 }; // , c[0] * 255];
|
|
}
|
|
else { // rgb
|
|
return { r: c[1] * 255, g: c[2] * 255, b: c[3] * 255, a: c[0] }; // , c[0] * 255];
|
|
}
|
|
}
|
|
function encodeColor(color) {
|
|
if (color && 'r' in color) {
|
|
return ['a' in color ? color.a : 1, color.r / 255, color.g / 255, color.b / 255];
|
|
}
|
|
else {
|
|
return [0, 0, 0, 0];
|
|
}
|
|
}
|
|
function arraysEqual(a, b) {
|
|
if (!a || !b)
|
|
return false;
|
|
if (a.length !== b.length)
|
|
return false;
|
|
for (var i = 0; i < a.length; i++)
|
|
if (a[i] !== b[i])
|
|
return false;
|
|
return true;
|
|
}
|
|
function objectsEqual(a, b) {
|
|
if (!a || !b)
|
|
return false;
|
|
for (var _i = 0, _a = Object.keys(a); _i < _a.length; _i++) {
|
|
var key = _a[_i];
|
|
if (a[key] !== b[key])
|
|
return false;
|
|
}
|
|
for (var _b = 0, _c = Object.keys(b); _b < _c.length; _b++) {
|
|
var key = _c[_b];
|
|
if (a[key] !== b[key])
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function findOrAddFont(fonts, font) {
|
|
for (var i = 0; i < fonts.length; i++) {
|
|
if (fonts[i].name === font.name)
|
|
return i;
|
|
}
|
|
fonts.push(font);
|
|
return fonts.length - 1;
|
|
}
|
|
function decodeObject(obj, keys, fonts) {
|
|
var result = {};
|
|
for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
|
|
var key = keys_1[_i];
|
|
var Key = upperFirst(key);
|
|
if (obj[Key] === undefined)
|
|
continue;
|
|
if (key === 'justification') {
|
|
result[key] = justification[obj[Key]];
|
|
}
|
|
else if (key === 'font') {
|
|
result[key] = fonts[obj[Key]];
|
|
}
|
|
else if (key === 'fillColor' || key === 'strokeColor') {
|
|
result[key] = decodeColor(obj[Key]);
|
|
}
|
|
else {
|
|
result[key] = obj[Key];
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function encodeObject(obj, keys, fonts) {
|
|
var _a;
|
|
var result = {};
|
|
for (var _i = 0, keys_2 = keys; _i < keys_2.length; _i++) {
|
|
var key = keys_2[_i];
|
|
var Key = upperFirst(key);
|
|
if (obj[key] === undefined)
|
|
continue;
|
|
if (key === 'justification') {
|
|
result[Key] = justification.indexOf((_a = obj[key]) !== null && _a !== void 0 ? _a : 'left');
|
|
}
|
|
else if (key === 'font') {
|
|
result[Key] = findOrAddFont(fonts, obj[key]);
|
|
}
|
|
else if (key === 'fillColor' || key === 'strokeColor') {
|
|
result[Key] = { Type: 1, Values: encodeColor(obj[key]) };
|
|
}
|
|
else {
|
|
result[Key] = obj[key];
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function decodeParagraphStyle(obj, fonts) {
|
|
return decodeObject(obj, paragraphStyleKeys, fonts);
|
|
}
|
|
function decodeStyle(obj, fonts) {
|
|
return decodeObject(obj, styleKeys, fonts);
|
|
}
|
|
function encodeParagraphStyle(obj, fonts) {
|
|
return encodeObject(obj, paragraphStyleKeys, fonts);
|
|
}
|
|
function encodeStyle(obj, fonts) {
|
|
return encodeObject(obj, styleKeys, fonts);
|
|
}
|
|
function deduplicateValues(base, runs, keys) {
|
|
if (!runs.length)
|
|
return;
|
|
var _loop_1 = function (key) {
|
|
var value = runs[0].style[key];
|
|
if (value !== undefined) {
|
|
var identical = false;
|
|
if (Array.isArray(value)) {
|
|
identical = runs.every(function (r) { return arraysEqual(r.style[key], value); });
|
|
}
|
|
else if (typeof value === 'object') {
|
|
identical = runs.every(function (r) { return objectsEqual(r.style[key], value); });
|
|
}
|
|
else {
|
|
identical = runs.every(function (r) { return r.style[key] === value; });
|
|
}
|
|
if (identical) {
|
|
base[key] = value;
|
|
}
|
|
}
|
|
var styleValue = base[key];
|
|
if (styleValue !== undefined) {
|
|
for (var _a = 0, runs_1 = runs; _a < runs_1.length; _a++) {
|
|
var r = runs_1[_a];
|
|
var same = false;
|
|
if (Array.isArray(value)) {
|
|
same = arraysEqual(r.style[key], value);
|
|
}
|
|
else if (typeof value === 'object') {
|
|
same = objectsEqual(r.style[key], value);
|
|
}
|
|
else {
|
|
same = r.style[key] === value;
|
|
}
|
|
if (same)
|
|
delete r.style[key];
|
|
}
|
|
}
|
|
};
|
|
for (var _i = 0, keys_3 = keys; _i < keys_3.length; _i++) {
|
|
var key = keys_3[_i];
|
|
_loop_1(key);
|
|
}
|
|
if (runs.every(function (x) { return Object.keys(x.style).length === 0; })) {
|
|
runs.length = 0;
|
|
}
|
|
}
|
|
export function decodeEngineData(engineData) {
|
|
var _a, _b, _c, _d, _e, _f;
|
|
// console.log('engineData', require('util').inspect(engineData, false, 99, true));
|
|
var engineDict = engineData.EngineDict;
|
|
var resourceDict = engineData.ResourceDict;
|
|
var fonts = resourceDict.FontSet.map(function (f) { return ({
|
|
name: f.Name,
|
|
script: f.Script,
|
|
type: f.FontType,
|
|
synthetic: f.Synthetic,
|
|
}); });
|
|
var text = engineDict.Editor.Text.replace(/\r/g, '\n');
|
|
var removedCharacters = 0;
|
|
while (/\n$/.test(text)) {
|
|
text = text.substr(0, text.length - 1);
|
|
removedCharacters++;
|
|
}
|
|
var result = {
|
|
text: text,
|
|
antiAlias: (_a = antialias[engineDict.AntiAlias]) !== null && _a !== void 0 ? _a : 'smooth',
|
|
useFractionalGlyphWidths: !!engineDict.UseFractionalGlyphWidths,
|
|
superscriptSize: resourceDict.SuperscriptSize,
|
|
superscriptPosition: resourceDict.SuperscriptPosition,
|
|
subscriptSize: resourceDict.SubscriptSize,
|
|
subscriptPosition: resourceDict.SubscriptPosition,
|
|
smallCapSize: resourceDict.SmallCapSize,
|
|
};
|
|
// shape
|
|
var photoshop = (_f = (_e = (_d = (_c = (_b = engineDict.Rendered) === null || _b === void 0 ? void 0 : _b.Shapes) === null || _c === void 0 ? void 0 : _c.Children) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.Cookie) === null || _f === void 0 ? void 0 : _f.Photoshop;
|
|
if (photoshop) {
|
|
result.shapeType = photoshop.ShapeType === 1 ? 'box' : 'point';
|
|
if (photoshop.PointBase)
|
|
result.pointBase = photoshop.PointBase;
|
|
if (photoshop.BoxBounds)
|
|
result.boxBounds = photoshop.BoxBounds;
|
|
}
|
|
// paragraph style
|
|
// const theNormalParagraphSheet = resourceDict.TheNormalParagraphSheet;
|
|
// const paragraphSheetSet = resourceDict.ParagraphSheetSet;
|
|
// const paragraphProperties = paragraphSheetSet[theNormalParagraphSheet].Properties;
|
|
var paragraphRun = engineData.EngineDict.ParagraphRun;
|
|
result.paragraphStyle = {}; // decodeParagraphStyle(paragraphProperties, fonts);
|
|
result.paragraphStyleRuns = [];
|
|
for (var i = 0; i < paragraphRun.RunArray.length; i++) {
|
|
var run_1 = paragraphRun.RunArray[i];
|
|
var length_1 = paragraphRun.RunLengthArray[i];
|
|
var style = decodeParagraphStyle(run_1.ParagraphSheet.Properties, fonts);
|
|
// const adjustments = {
|
|
// axis: run.Adjustments.Axis,
|
|
// xy: run.Adjustments.XY,
|
|
// };
|
|
result.paragraphStyleRuns.push({ length: length_1, style: style /*, adjustments*/ });
|
|
}
|
|
for (var counter = removedCharacters; result.paragraphStyleRuns.length && counter > 0; counter--) {
|
|
if (--result.paragraphStyleRuns[result.paragraphStyleRuns.length - 1].length === 0) {
|
|
result.paragraphStyleRuns.pop();
|
|
}
|
|
}
|
|
deduplicateValues(result.paragraphStyle, result.paragraphStyleRuns, paragraphStyleKeys);
|
|
if (!result.paragraphStyleRuns.length)
|
|
delete result.paragraphStyleRuns;
|
|
// style
|
|
// const theNormalStyleSheet = resourceDict.TheNormalStyleSheet;
|
|
// const styleSheetSet = resourceDict.StyleSheetSet;
|
|
// const styleSheetData = styleSheetSet[theNormalStyleSheet].StyleSheetData;
|
|
var styleRun = engineData.EngineDict.StyleRun;
|
|
result.style = {}; // decodeStyle(styleSheetData, fonts);
|
|
result.styleRuns = [];
|
|
for (var i = 0; i < styleRun.RunArray.length; i++) {
|
|
var length_2 = styleRun.RunLengthArray[i];
|
|
var style = decodeStyle(styleRun.RunArray[i].StyleSheet.StyleSheetData, fonts);
|
|
if (!style.font)
|
|
style.font = fonts[0];
|
|
result.styleRuns.push({ length: length_2, style: style });
|
|
}
|
|
for (var counter = removedCharacters; result.styleRuns.length && counter > 0; counter--) {
|
|
if (--result.styleRuns[result.styleRuns.length - 1].length === 0) {
|
|
result.styleRuns.pop();
|
|
}
|
|
}
|
|
deduplicateValues(result.style, result.styleRuns, styleKeys);
|
|
if (!result.styleRuns.length)
|
|
delete result.styleRuns;
|
|
return result;
|
|
}
|
|
export function encodeEngineData(data) {
|
|
var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
|
|
var text = "".concat((data.text || '').replace(/\r?\n/g, '\r'), "\r");
|
|
var fonts = [
|
|
{ name: 'AdobeInvisFont', script: 0, type: 0, synthetic: 0 },
|
|
];
|
|
var defFont = ((_a = data.style) === null || _a === void 0 ? void 0 : _a.font) || ((_c = (_b = data.styleRuns) === null || _b === void 0 ? void 0 : _b.find(function (s) { return s.style.font; })) === null || _c === void 0 ? void 0 : _c.style.font) || defaultFont;
|
|
var paragraphRunArray = [];
|
|
var paragraphRunLengthArray = [];
|
|
var paragraphRuns = data.paragraphStyleRuns;
|
|
if (paragraphRuns && paragraphRuns.length) {
|
|
var leftLength_1 = text.length;
|
|
for (var _i = 0, paragraphRuns_1 = paragraphRuns; _i < paragraphRuns_1.length; _i++) {
|
|
var run_2 = paragraphRuns_1[_i];
|
|
var runLength = Math.min(run_2.length, leftLength_1);
|
|
leftLength_1 -= runLength;
|
|
if (!runLength)
|
|
continue; // ignore 0 size runs
|
|
// extend last run if it's only for trailing \r
|
|
if (leftLength_1 === 1 && run_2 === paragraphRuns[paragraphRuns.length - 1]) {
|
|
runLength++;
|
|
leftLength_1--;
|
|
}
|
|
paragraphRunLengthArray.push(runLength);
|
|
paragraphRunArray.push({
|
|
ParagraphSheet: {
|
|
DefaultStyleSheet: 0,
|
|
Properties: encodeParagraphStyle(__assign(__assign(__assign({}, defaultParagraphStyle), data.paragraphStyle), run_2.style), fonts),
|
|
},
|
|
Adjustments: { Axis: [1, 0, 1], XY: [0, 0] },
|
|
});
|
|
}
|
|
if (leftLength_1) {
|
|
paragraphRunLengthArray.push(leftLength_1);
|
|
paragraphRunArray.push({
|
|
ParagraphSheet: {
|
|
DefaultStyleSheet: 0,
|
|
Properties: encodeParagraphStyle(__assign(__assign({}, defaultParagraphStyle), data.paragraphStyle), fonts),
|
|
},
|
|
Adjustments: { Axis: [1, 0, 1], XY: [0, 0] },
|
|
});
|
|
}
|
|
}
|
|
else {
|
|
for (var i = 0, last = 0; i < text.length; i++) {
|
|
if (text.charCodeAt(i) === 13) { // \r
|
|
paragraphRunLengthArray.push(i - last + 1);
|
|
paragraphRunArray.push({
|
|
ParagraphSheet: {
|
|
DefaultStyleSheet: 0,
|
|
Properties: encodeParagraphStyle(__assign(__assign({}, defaultParagraphStyle), data.paragraphStyle), fonts),
|
|
},
|
|
Adjustments: { Axis: [1, 0, 1], XY: [0, 0] },
|
|
});
|
|
last = i + 1;
|
|
}
|
|
}
|
|
}
|
|
var styleSheetData = encodeStyle(__assign(__assign({}, defaultStyle), { font: defFont }), fonts);
|
|
var styleRuns = data.styleRuns || [{ length: text.length, style: data.style || {} }];
|
|
var styleRunArray = [];
|
|
var styleRunLengthArray = [];
|
|
var leftLength = text.length;
|
|
for (var _o = 0, styleRuns_1 = styleRuns; _o < styleRuns_1.length; _o++) {
|
|
var run_3 = styleRuns_1[_o];
|
|
var runLength = Math.min(run_3.length, leftLength);
|
|
leftLength -= runLength;
|
|
if (!runLength)
|
|
continue; // ignore 0 size runs
|
|
// extend last run if it's only for trailing \r
|
|
if (leftLength === 1 && run_3 === styleRuns[styleRuns.length - 1]) {
|
|
runLength++;
|
|
leftLength--;
|
|
}
|
|
styleRunLengthArray.push(runLength);
|
|
styleRunArray.push({
|
|
StyleSheet: {
|
|
StyleSheetData: encodeStyle(__assign(__assign({ kerning: 0, autoKerning: true, fillColor: { r: 0, g: 0, b: 0 } }, data.style), run_3.style), fonts),
|
|
},
|
|
});
|
|
}
|
|
// add extra run to the end if existing ones didn't fill it up
|
|
if (leftLength && styleRuns.length) {
|
|
styleRunLengthArray.push(leftLength);
|
|
styleRunArray.push({
|
|
StyleSheet: {
|
|
StyleSheetData: encodeStyle(__assign({ kerning: 0, autoKerning: true, fillColor: { r: 0, g: 0, b: 0 } }, data.style), fonts),
|
|
},
|
|
});
|
|
}
|
|
var gridInfo = __assign(__assign({}, defaultGridInfo), data.gridInfo);
|
|
var WritingDirection = data.orientation === 'vertical' ? 2 : 0;
|
|
var Procession = data.orientation === 'vertical' ? 1 : 0;
|
|
var ShapeType = data.shapeType === 'box' ? 1 : 0;
|
|
var Photoshop = {
|
|
ShapeType: ShapeType,
|
|
};
|
|
if (ShapeType === 0) {
|
|
Photoshop.PointBase = data.pointBase || [0, 0];
|
|
}
|
|
else {
|
|
Photoshop.BoxBounds = data.boxBounds || [0, 0, 0, 0];
|
|
}
|
|
// needed for correct order of properties
|
|
Photoshop.Base = {
|
|
ShapeType: ShapeType,
|
|
TransformPoint0: [1, 0],
|
|
TransformPoint1: [0, 1],
|
|
TransformPoint2: [0, 0],
|
|
};
|
|
var defaultResources = {
|
|
KinsokuSet: [
|
|
{
|
|
Name: 'PhotoshopKinsokuHard',
|
|
NoStart: '、。，．・：；？！ー―’”）〕］｝〉》」』】ヽヾゝゞ々ぁぃぅぇぉっゃゅょゎァィゥェォッャュョヮヵヶ゛゜?!)]},.:;℃℉¢％‰',
|
|
NoEnd: '‘“（〔［｛〈《「『【([{￥＄£＠§〒＃',
|
|
Keep: '―‥',
|
|
Hanging: '、。.,',
|
|
},
|
|
{
|
|
Name: 'PhotoshopKinsokuSoft',
|
|
NoStart: '、。，．・：；？！’”）〕］｝〉》」』】ヽヾゝゞ々',
|
|
NoEnd: '‘“（〔［｛〈《「『【',
|
|
Keep: '―‥',
|
|
Hanging: '、。.,',
|
|
},
|
|
],
|
|
MojiKumiSet: [
|
|
{ InternalName: 'Photoshop6MojiKumiSet1' },
|
|
{ InternalName: 'Photoshop6MojiKumiSet2' },
|
|
{ InternalName: 'Photoshop6MojiKumiSet3' },
|
|
{ InternalName: 'Photoshop6MojiKumiSet4' },
|
|
],
|
|
TheNormalStyleSheet: 0,
|
|
TheNormalParagraphSheet: 0,
|
|
ParagraphSheetSet: [
|
|
{
|
|
Name: 'Normal RGB',
|
|
DefaultStyleSheet: 0,
|
|
Properties: encodeParagraphStyle(__assign(__assign({}, defaultParagraphStyle), data.paragraphStyle), fonts),
|
|
},
|
|
],
|
|
StyleSheetSet: [
|
|
{
|
|
Name: 'Normal RGB',
|
|
StyleSheetData: styleSheetData,
|
|
},
|
|
],
|
|
FontSet: fonts.map(function (f) { return ({
|
|
Name: f.name,
|
|
Script: f.script || 0,
|
|
FontType: f.type || 0,
|
|
Synthetic: f.synthetic || 0,
|
|
}); }),
|
|
SuperscriptSize: (_d = data.superscriptSize) !== null && _d !== void 0 ? _d : 0.583,
|
|
SuperscriptPosition: (_e = data.superscriptPosition) !== null && _e !== void 0 ? _e : 0.333,
|
|
SubscriptSize: (_f = data.subscriptSize) !== null && _f !== void 0 ? _f : 0.583,
|
|
SubscriptPosition: (_g = data.subscriptPosition) !== null && _g !== void 0 ? _g : 0.333,
|
|
SmallCapSize: (_h = data.smallCapSize) !== null && _h !== void 0 ? _h : 0.7,
|
|
};
|
|
var engineData = {
|
|
EngineDict: {
|
|
Editor: { Text: text },
|
|
ParagraphRun: {
|
|
DefaultRunData: {
|
|
ParagraphSheet: { DefaultStyleSheet: 0, Properties: {} },
|
|
Adjustments: { Axis: [1, 0, 1], XY: [0, 0] },
|
|
},
|
|
RunArray: paragraphRunArray,
|
|
RunLengthArray: paragraphRunLengthArray,
|
|
IsJoinable: 1,
|
|
},
|
|
StyleRun: {
|
|
DefaultRunData: { StyleSheet: { StyleSheetData: {} } },
|
|
RunArray: styleRunArray,
|
|
RunLengthArray: styleRunLengthArray,
|
|
IsJoinable: 2,
|
|
},
|
|
GridInfo: {
|
|
GridIsOn: !!gridInfo.isOn,
|
|
ShowGrid: !!gridInfo.show,
|
|
GridSize: (_j = gridInfo.size) !== null && _j !== void 0 ? _j : 18,
|
|
GridLeading: (_k = gridInfo.leading) !== null && _k !== void 0 ? _k : 22,
|
|
GridColor: { Type: 1, Values: encodeColor(gridInfo.color) },
|
|
GridLeadingFillColor: { Type: 1, Values: encodeColor(gridInfo.color) },
|
|
AlignLineHeightToGridFlags: !!gridInfo.alignLineHeightToGridFlags,
|
|
},
|
|
AntiAlias: antialias.indexOf((_l = data.antiAlias) !== null && _l !== void 0 ? _l : 'sharp'),
|
|
UseFractionalGlyphWidths: (_m = data.useFractionalGlyphWidths) !== null && _m !== void 0 ? _m : true,
|
|
Rendered: {
|
|
Version: 1,
|
|
Shapes: {
|
|
WritingDirection: WritingDirection,
|
|
Children: [
|
|
{
|
|
ShapeType: ShapeType,
|
|
Procession: Procession,
|
|
Lines: { WritingDirection: WritingDirection, Children: [] },
|
|
Cookie: { Photoshop: Photoshop },
|
|
},
|
|
],
|
|
},
|
|
},
|
|
},
|
|
ResourceDict: __assign({}, defaultResources),
|
|
DocumentResources: __assign({}, defaultResources),
|
|
};
|
|
// console.log('encodeEngineData', require('util').inspect(engineData, false, 99, true));
|
|
return engineData;
|
|
}
|
|
//# sourceMappingURL=text.js.map
|