@yft-design/psd-lib 1.0.1

package/dist/text.js

@@ -0,0 +1,556 @@
+const defaultFont = {
+    name: 'MyriadPro-Regular',
+    script: 0,
+    type: 0,
+    synthetic: 0,
+};
+const 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,
+};
+const 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,
+};
+const 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,
+};
+const paragraphStyleKeys = [
+    'justification', 'firstLineIndent', 'startIndent', 'endIndent', 'spaceBefore', 'spaceAfter',
+    'autoHyphenate', 'hyphenatedWordSize', 'preHyphen', 'postHyphen', 'consecutiveHyphens',
+    'zone', 'wordSpacing', 'letterSpacing', 'glyphSpacing', 'autoLeading', 'leadingType',
+    'hanging', 'burasagari', 'kinsokuOrder', 'everyLineComposer',
+];
+const 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',
+];
+const antialias = ['none', 'crisp', 'strong', 'smooth', 'sharp'];
+const justification = [
+    'left', // 0
+    'right', // 1
+    'center', // 2
+    'justify-left', // 3
+    'justify-right', // 4
+    'justify-center', // 5
+    'justify-all', // 6
+];
+function upperFirst(value) {
+    return value.substring(0, 1).toUpperCase() + value.substring(1);
+}
+function decodeColor(color) {
+    const c = color.Values;
+    switch (color.Type) {
+        case 0: return { k: c[1] * 255 }; // grayscale (alpha?)
+        case 1: return c[0] === 1 ?
+            { r: c[1] * 255, g: c[2] * 255, b: c[3] * 255 } : // rgb
+            { r: c[1] * 255, g: c[2] * 255, b: c[3] * 255, a: c[0] * 255 }; // rgba
+        case 2: return { c: c[1] * 255, m: c[2] * 255, y: c[3] * 255, k: c[4] * 255 }; // cmyk (alpha?)
+        default: throw new Error('Unknown color type in text layer');
+    }
+}
+function encodeColor(color) {
+    if (!color) {
+        return { Type: 1, Values: [0, 0, 0, 0] };
+    }
+    else if ('r' in color) {
+        return { Type: 1, Values: ['a' in color ? color.a / 255 : 1, color.r / 255, color.g / 255, color.b / 255] };
+    }
+    else if ('c' in color) {
+        return { Type: 2, Values: [1, color.c / 255, color.m / 255, color.y / 255, color.k / 255] };
+    }
+    else if ('k' in color) {
+        return { Type: 0, Values: [1, color.k / 255] };
+    }
+    else {
+        throw new Error('Invalid color type in text layer');
+    }
+}
+function arraysEqual(a, b) {
+    if (!a || !b)
+        return false;
+    if (a.length !== b.length)
+        return false;
+    for (let 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 (const key of Object.keys(a))
+        if (a[key] !== b[key])
+            return false;
+    for (const key of Object.keys(b))
+        if (a[key] !== b[key])
+            return false;
+    return true;
+}
+function findOrAddFont(fonts, font) {
+    for (let 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) {
+    const result = {};
+    for (const key of keys) {
+        const 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) {
+    const result = {};
+    for (const key of keys) {
+        const Key = upperFirst(key);
+        if (obj[key] === undefined)
+            continue;
+        if (key === 'justification') {
+            result[Key] = justification.indexOf(obj[key] ?? 'left');
+        }
+        else if (key === 'font') {
+            result[Key] = findOrAddFont(fonts, obj[key]);
+        }
+        else if (key === 'fillColor' || key === 'strokeColor') {
+            result[Key] = 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;
+    for (const key of keys) {
+        const value = runs[0].style[key];
+        if (value !== undefined) {
+            let identical = false;
+            if (Array.isArray(value)) {
+                identical = runs.every(r => arraysEqual(r.style[key], value));
+            }
+            else if (typeof value === 'object') {
+                identical = runs.every(r => objectsEqual(r.style[key], value));
+            }
+            else {
+                identical = runs.every(r => r.style[key] === value);
+            }
+            if (identical) {
+                base[key] = value;
+            }
+        }
+        const styleValue = base[key];
+        if (styleValue !== undefined) {
+            for (const r of runs) {
+                let 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];
+            }
+        }
+    }
+    if (runs.every(x => Object.keys(x.style).length === 0)) {
+        runs.length = 0;
+    }
+}
+export function decodeEngineData(engineData) {
+    // console.log('engineData', require('util').inspect(engineData, false, 99, true));
+    const engineDict = engineData.EngineDict;
+    const resourceDict = engineData.ResourceDict;
+    const fonts = resourceDict.FontSet.map(f => ({
+        name: f.Name,
+        script: f.Script,
+        type: f.FontType,
+        synthetic: f.Synthetic,
+    }));
+    let text = engineDict.Editor.Text.replace(/\r/g, '\n');
+    let removedCharacters = 0;
+    while (/\n$/.test(text)) {
+        text = text.substring(0, text.length - 1);
+        removedCharacters++;
+    }
+    const result = {
+        text,
+        antiAlias: antialias[engineDict.AntiAlias] ?? 'smooth',
+        useFractionalGlyphWidths: !!engineDict.UseFractionalGlyphWidths,
+        superscriptSize: resourceDict.SuperscriptSize,
+        superscriptPosition: resourceDict.SuperscriptPosition,
+        subscriptSize: resourceDict.SubscriptSize,
+        subscriptPosition: resourceDict.SubscriptPosition,
+        smallCapSize: resourceDict.SmallCapSize,
+    };
+    // shape
+    const photoshop = engineDict.Rendered?.Shapes?.Children?.[0]?.Cookie?.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;
+    const paragraphRun = engineDict.ParagraphRun;
+    result.paragraphStyle = {}; // decodeParagraphStyle(paragraphProperties, fonts);
+    result.paragraphStyleRuns = [];
+    for (let i = 0; i < paragraphRun.RunArray.length; i++) {
+        const run = paragraphRun.RunArray[i];
+        const length = paragraphRun.RunLengthArray[i];
+        const style = decodeParagraphStyle(run.ParagraphSheet.Properties, fonts);
+        // const adjustments = {
+        //   axis: run.Adjustments.Axis,
+        //   xy: run.Adjustments.XY,
+        // };
+        result.paragraphStyleRuns.push({ length, style /*, adjustments*/ });
+    }
+    for (let 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;
+    const styleRun = engineDict.StyleRun;
+    result.style = {}; // decodeStyle(styleSheetData, fonts);
+    result.styleRuns = [];
+    for (let i = 0; i < styleRun.RunArray.length; i++) {
+        const length = styleRun.RunLengthArray[i];
+        const style = decodeStyle(styleRun.RunArray[i].StyleSheet.StyleSheetData, fonts);
+        if (!style.font)
+            style.font = fonts[0];
+        result.styleRuns.push({ length, style });
+    }
+    for (let 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) {
+    const text = `${(data.text || '').replace(/\r?\n/g, '\r')}\r`;
+    const fonts = [
+        { name: 'AdobeInvisFont', script: 0, type: 0, synthetic: 0 },
+    ];
+    const defFont = data.style?.font || data.styleRuns?.find(s => s.style.font)?.style.font || defaultFont;
+    const paragraphRunArray = [];
+    const paragraphRunLengthArray = [];
+    const paragraphRuns = data.paragraphStyleRuns;
+    if (paragraphRuns && paragraphRuns.length) {
+        let leftLength = text.length;
+        for (const run of paragraphRuns) {
+            let runLength = Math.min(run.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 === paragraphRuns[paragraphRuns.length - 1]) {
+                runLength++;
+                leftLength--;
+            }
+            paragraphRunLengthArray.push(runLength);
+            paragraphRunArray.push({
+                ParagraphSheet: {
+                    DefaultStyleSheet: 0,
+                    Properties: encodeParagraphStyle({ ...defaultParagraphStyle, ...data.paragraphStyle, ...run.style }, fonts),
+                },
+                Adjustments: { Axis: [1, 0, 1], XY: [0, 0] },
+            });
+        }
+        if (leftLength) {
+            paragraphRunLengthArray.push(leftLength);
+            paragraphRunArray.push({
+                ParagraphSheet: {
+                    DefaultStyleSheet: 0,
+                    Properties: encodeParagraphStyle({ ...defaultParagraphStyle, ...data.paragraphStyle }, fonts),
+                },
+                Adjustments: { Axis: [1, 0, 1], XY: [0, 0] },
+            });
+        }
+    }
+    else {
+        for (let 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({ ...defaultParagraphStyle, ...data.paragraphStyle }, fonts),
+                    },
+                    Adjustments: { Axis: [1, 0, 1], XY: [0, 0] },
+                });
+                last = i + 1;
+            }
+        }
+    }
+    const styleSheetData = encodeStyle({ ...defaultStyle, font: defFont }, fonts);
+    const styleRuns = data.styleRuns || [{ length: text.length, style: data.style || {} }];
+    const styleRunArray = [];
+    const styleRunLengthArray = [];
+    let leftLength = text.length;
+    for (const run of styleRuns) {
+        let runLength = Math.min(run.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 === styleRuns[styleRuns.length - 1]) {
+            runLength++;
+            leftLength--;
+        }
+        styleRunLengthArray.push(runLength);
+        styleRunArray.push({
+            StyleSheet: {
+                StyleSheetData: encodeStyle({
+                    kerning: 0,
+                    autoKerning: true,
+                    fillColor: { r: 0, g: 0, b: 0 },
+                    ...data.style,
+                    ...run.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({
+                    kerning: 0,
+                    autoKerning: true,
+                    fillColor: { r: 0, g: 0, b: 0 },
+                    ...data.style,
+                }, fonts),
+            },
+        });
+    }
+    const gridInfo = { ...defaultGridInfo, ...data.gridInfo };
+    const WritingDirection = data.orientation === 'vertical' ? 2 : 0;
+    const Procession = data.orientation === 'vertical' ? 1 : 0;
+    const ShapeType = data.shapeType === 'box' ? 1 : 0;
+    const Photoshop = {
+        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,
+        TransformPoint0: [1, 0],
+        TransformPoint1: [0, 1],
+        TransformPoint2: [0, 0],
+    };
+    const 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({ ...defaultParagraphStyle, ...data.paragraphStyle }, fonts),
+            },
+        ],
+        StyleSheetSet: [
+            {
+                Name: 'Normal RGB',
+                StyleSheetData: styleSheetData,
+            },
+        ],
+        FontSet: fonts.map(f => ({
+            Name: f.name,
+            Script: f.script || 0,
+            FontType: f.type || 0,
+            Synthetic: f.synthetic || 0,
+        })),
+        SuperscriptSize: data.superscriptSize ?? 0.583,
+        SuperscriptPosition: data.superscriptPosition ?? 0.333,
+        SubscriptSize: data.subscriptSize ?? 0.583,
+        SubscriptPosition: data.subscriptPosition ?? 0.333,
+        SmallCapSize: data.smallCapSize ?? 0.7,
+    };
+    const 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: gridInfo.size ?? 18,
+                GridLeading: gridInfo.leading ?? 22,
+                GridColor: encodeColor(gridInfo.color),
+                GridLeadingFillColor: encodeColor(gridInfo.color),
+                AlignLineHeightToGridFlags: !!gridInfo.alignLineHeightToGridFlags,
+            },
+            AntiAlias: antialias.indexOf(data.antiAlias ?? 'sharp'),
+            UseFractionalGlyphWidths: data.useFractionalGlyphWidths ?? true,
+            Rendered: {
+                Version: 1,
+                Shapes: {
+                    WritingDirection,
+                    Children: [
+                        {
+                            ShapeType,
+                            Procession,
+                            Lines: { WritingDirection, Children: [] },
+                            Cookie: { Photoshop },
+                        },
+                    ],
+                },
+            },
+        },
+        ResourceDict: { ...defaultResources },
+        DocumentResources: { ...defaultResources },
+    };
+    // console.log('encodeEngineData', require('util').inspect(engineData, false, 99, true));
+    return engineData;
+}

package/dist/utf8.d.ts

@@ -0,0 +1,4 @@
+export declare function stringLengthInBytes(value: string): number;
+export declare function encodeStringTo(buffer: Uint8Array | Buffer, offset: number, value: string): number;
+export declare function encodeString(value: string): Uint8Array;
+export declare function decodeString(value: Uint8Array): string;