@idraw/util 0.2.0-alpha.9 → 0.3.0-0.3.0-beta.6.0

package/dist/esm/lib/is.js

@@ -0,0 +1,81 @@
+import { isColorStr } from './color';
+function number(value) {
+    return (typeof value === 'number' && (value > 0 || value <= 0));
+}
+function x(value) {
+    return number(value);
+}
+function y(value) {
+    return number(value);
+}
+function w(value) {
+    return (typeof value === 'number' && value >= 0);
+}
+function h(value) {
+    return (typeof value === 'number' && value >= 0);
+}
+function angle(value) {
+    return (typeof value === 'number' && value >= -360 && value <= 360);
+}
+function borderWidth(value) {
+    return w(value);
+}
+function borderRadius(value) {
+    return number(value) && value >= 0;
+}
+function color(value) {
+    return isColorStr(value);
+}
+function imageURL(value) {
+    return (typeof value === 'string' && /^(http:\/\/|https:\/\/|\.\/|\/)/.test(`${value}`));
+}
+function imageBase64(value) {
+    return (typeof value === 'string' && /^(data:image\/)/.test(`${value}`));
+}
+function imageSrc(value) {
+    return (imageBase64(value) || imageURL(value));
+}
+function svg(value) {
+    return (typeof value === 'string' && /^(<svg[\s]{1,}|<svg>)/i.test(`${value}`.trim()) && /<\/[\s]{0,}svg>$/i.test(`${value}`.trim()));
+}
+function html(value) {
+    let result = false;
+    if (typeof value === 'string') {
+        let div = document.createElement('div');
+        div.innerHTML = value;
+        if (div.children.length > 0) {
+            result = true;
+        }
+        div = null;
+    }
+    return result;
+}
+function text(value) {
+    return typeof value === 'string';
+}
+function fontSize(value) {
+    return number(value) && value > 0;
+}
+function lineHeight(value) {
+    return number(value) && value > 0;
+}
+function strokeWidth(value) {
+    return number(value) && value > 0;
+}
+function textAlign(value) {
+    return ['center', 'left', 'right'].includes(value);
+}
+function fontFamily(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function fontWeight(value) {
+    return ['bold'].includes(value);
+}
+const is = {
+    x, y, w, h, angle, number,
+    borderWidth, borderRadius, color,
+    imageSrc, imageURL, imageBase64, svg, html,
+    text, fontSize, lineHeight, textAlign, fontFamily, fontWeight,
+    strokeWidth,
+};
+export default is;

package/dist/esm/lib/istype.d.ts

@@ -0,0 +1,13 @@
+declare const istype: {
+    type(data: any, lowerCase?: boolean): string;
+    array(data: any): boolean;
+    json(data: any): boolean;
+    function(data: any): boolean;
+    asyncFunction(data: any): boolean;
+    string(data: any): boolean;
+    number(data: any): boolean;
+    undefined(data: any): boolean;
+    null(data: any): boolean;
+    promise(data: any): boolean;
+};
+export default istype;

package/dist/esm/lib/istype.js

@@ -0,0 +1,39 @@
+function parsePrototype(data) {
+    const typeStr = Object.prototype.toString.call(data) || '';
+    const result = typeStr.replace(/(\[object|\])/ig, '').trim();
+    return result;
+}
+const istype = {
+    type(data, lowerCase) {
+        const result = parsePrototype(data);
+        return lowerCase === true ? result.toLocaleLowerCase() : result;
+    },
+    array(data) {
+        return parsePrototype(data) === 'Array';
+    },
+    json(data) {
+        return parsePrototype(data) === 'Object';
+    },
+    function(data) {
+        return parsePrototype(data) === 'Function';
+    },
+    asyncFunction(data) {
+        return parsePrototype(data) === 'AsyncFunction';
+    },
+    string(data) {
+        return parsePrototype(data) === 'String';
+    },
+    number(data) {
+        return parsePrototype(data) === 'Number';
+    },
+    undefined(data) {
+        return parsePrototype(data) === 'Undefined';
+    },
+    null(data) {
+        return parsePrototype(data) === 'Null';
+    },
+    promise(data) {
+        return parsePrototype(data) === 'Promise';
+    },
+};
+export default istype;

package/dist/esm/lib/loader.d.ts

@@ -0,0 +1,6 @@
+export declare function loadImage(src: string): Promise<HTMLImageElement>;
+export declare function loadSVG(svg: string): Promise<HTMLImageElement>;
+export declare function loadHTML(html: string, opts: {
+    width: number;
+    height: number;
+}): Promise<HTMLImageElement>;

package/dist/esm/lib/loader.js

@@ -0,0 +1,41 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { parseHTMLToDataURL, parseSVGToDataURL } from './parser';
+const { Image } = window;
+export function loadImage(src) {
+    return new Promise((resolve, reject) => {
+        const img = new Image;
+        img.crossOrigin = 'anonymous';
+        img.onload = function () {
+            resolve(img);
+        };
+        img.onabort = reject;
+        img.onerror = reject;
+        img.src = src;
+    });
+}
+export function loadSVG(svg) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const dataURL = yield parseSVGToDataURL(svg);
+        const image = yield loadImage(dataURL);
+        return image;
+    });
+}
+function filterAmpersand(str) {
+    return str.replace(/\&/ig, '&');
+}
+export function loadHTML(html, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        html = filterAmpersand(html);
+        const dataURL = yield parseHTMLToDataURL(html, opts);
+        const image = yield loadImage(dataURL);
+        return image;
+    });
+}

package/dist/esm/lib/parser.d.ts

@@ -0,0 +1,5 @@
+export declare function parseHTMLToDataURL(html: string, opts: {
+    width: number;
+    height: number;
+}): Promise<string>;
+export declare function parseSVGToDataURL(svg: string): Promise<string>;

package/dist/esm/lib/parser.js

@@ -0,0 +1,41 @@
+export function parseHTMLToDataURL(html, opts) {
+    const { width, height } = opts;
+    return new Promise((resolve, reject) => {
+        const _svg = `
+    <svg xmlns="http://www.w3.org/2000/svg" width="${width || ''}" height = "${height || ''}">
+      <foreignObject width="100%" height="100%">
+        <div xmlns = "http://www.w3.org/1999/xhtml">
+          ${html}
+        </div>
+      </foreignObject>
+    </svg>
+    `;
+        const blob = new Blob([_svg], { type: 'image/svg+xml;charset=utf-8' });
+        const reader = new FileReader();
+        reader.readAsDataURL(blob);
+        reader.onload = function (event) {
+            var _a;
+            const base64 = (_a = event === null || event === void 0 ? void 0 : event.target) === null || _a === void 0 ? void 0 : _a.result;
+            resolve(base64);
+        };
+        reader.onerror = function (err) {
+            reject(err);
+        };
+    });
+}
+export function parseSVGToDataURL(svg) {
+    return new Promise((resolve, reject) => {
+        const _svg = svg;
+        const blob = new Blob([_svg], { type: 'image/svg+xml;charset=utf-8' });
+        const reader = new FileReader();
+        reader.readAsDataURL(blob);
+        reader.onload = function (event) {
+            var _a;
+            const base64 = (_a = event === null || event === void 0 ? void 0 : event.target) === null || _a === void 0 ? void 0 : _a.result;
+            resolve(base64);
+        };
+        reader.onerror = function (err) {
+            reject(err);
+        };
+    });
+}

package/dist/esm/lib/time.d.ts

@@ -0,0 +1,5 @@
+type Middleware = (ctx: any, next: Middleware) => any;
+export declare function compose(middleware: Middleware[]): (context: any, next?: Middleware) => any;
+export declare function delay(time: number): Promise<void>;
+export declare function throttle(fn: (...args: any[]) => any, timeout: number): (...args: any[]) => any;
+export {};

package/dist/esm/lib/time.js

@@ -0,0 +1,38 @@
+export function compose(middleware) {
+    return function (context, next) {
+        return dispatch(0);
+        function dispatch(i) {
+            let fn = middleware[i];
+            if (i === middleware.length && next) {
+                fn = next;
+            }
+            if (!fn)
+                return Promise.resolve();
+            try {
+                return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
+            }
+            catch (err) {
+                return Promise.reject(err);
+            }
+        }
+    };
+}
+export function delay(time) {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve();
+        }, time);
+    });
+}
+export function throttle(fn, timeout) {
+    let timer = -1;
+    return function (...args) {
+        if (timer > 0) {
+            return;
+        }
+        timer = setTimeout(() => {
+            fn(...args);
+            timer = -1;
+        }, timeout);
+    };
+}

package/dist/esm/lib/uuid.d.ts

@@ -0,0 +1 @@
+export declare function createUUID(): string;

package/dist/esm/lib/uuid.js

@@ -0,0 +1,6 @@
+export function createUUID() {
+    function str4() {
+        return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
+    }
+    return `${str4()}${str4()}-${str4()}-${str4()}-${str4()}-${str4()}${str4()}${str4()}`;
+}