x4js 1.4.52 → 1.5.0

package/lib/esm/styles.d.ts

@@ -0,0 +1,85 @@
+/**
+*  ___   ___ __
+*  \  \_/  /  / _
+*   \     /  /_| |_
+*   /  _  \____   _|
+*  /__/ \__\   |_|
+*
+* @file styles.ts
+* @author Etienne Cochard
+*
+* Copyright (c) 2019-2022 R-libre ingenierie
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+* of the Software, and to permit persons to whom the Software is furnished to do so,
+* subject to the following conditions:
+* The above copyright notice and this permission notice shall be included in all copies
+* or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**/
+/**
+ *  -- [ @STYLESHEET ] -----------------------------------------------------------------
+ */
+export declare class Stylesheet {
+    private m_sheet;
+    private m_rules;
+    constructor();
+    /**
+     * add a new rule to the style sheet
+     * @param {string} name - internal rule name
+     * @param {string} definition - css definition of the rule
+     * @example
+     * setRule('xbody', "body { background-color: #ff0000; }" );
+     */
+    setRule(name: string, definition: any): void;
+    /**
+     * return the style variable value
+     * @param name - variable name
+     * @example
+     * ```
+     * let color = Component.getCss( ).getVar( 'button-color' );
+     * ```
+     */
+    static getVar(name: string): any;
+    static guid: number;
+    static doc_style: CSSStyleDeclaration;
+}
+/**
+ *  -- [ @CSSPARSER ] -----------------------------------------------------------------
+ *
+ * adaptation of jss-for-node-js
+ */
+export declare class CSSParser {
+    private result;
+    parse(css: any): string;
+    static mk_string(rules: any): string;
+    private parse_json;
+    private makePropertyName;
+    private makeSelectorName;
+    addProperty(scope: string, property: string, value: any): void;
+}
+export declare class ComputedStyle {
+    m_style: CSSStyleDeclaration;
+    constructor(style: CSSStyleDeclaration);
+    /**
+     * return the raw value
+     */
+    value(name: string): string;
+    /**
+     * return the interpreted value
+     */
+    parse(name: string): number;
+    /**
+     *
+     */
+    get style(): CSSStyleDeclaration;
+}

package/lib/esm/styles.js

@@ -0,0 +1,270 @@
+/**
+*  ___   ___ __
+*  \  \_/  /  / _
+*   \     /  /_| |_
+*   /  _  \____   _|
+*  /__/ \__\   |_|
+*
+* @file styles.ts
+* @author Etienne Cochard
+*
+* Copyright (c) 2019-2022 R-libre ingenierie
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+* of the Software, and to permit persons to whom the Software is furnished to do so,
+* subject to the following conditions:
+* The above copyright notice and this permission notice shall be included in all copies
+* or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**/
+import { x4document } from './x4dom';
+import { pascalCase, isString, isArray } from "./tools";
+/**
+ *  -- [ @STYLESHEET ] -----------------------------------------------------------------
+ */
+export class Stylesheet {
+    m_sheet;
+    m_rules = new Map();
+    constructor() {
+        function getStyleSheet(name) {
+            for (let i = 0; i < x4document.styleSheets.length; i++) {
+                let sheet = x4document.styleSheets[i];
+                if (sheet.title === name) {
+                    return sheet;
+                }
+            }
+        }
+        this.m_sheet = getStyleSheet('@dynamic-css');
+        if (!this.m_sheet) {
+            let dom = x4document.createElement('style');
+            dom.setAttribute('id', '@dynamic-css');
+            x4document.head.appendChild(dom);
+            this.m_sheet = dom.sheet;
+        }
+    }
+    /**
+     * add a new rule to the style sheet
+     * @param {string} name - internal rule name
+     * @param {string} definition - css definition of the rule
+     * @example
+     * setRule('xbody', "body { background-color: #ff0000; }" );
+     */
+    setRule(name, definition) {
+        if (isString(definition)) {
+            let index = this.m_rules.get(name);
+            if (index !== undefined) {
+                this.m_sheet.deleteRule(index);
+            }
+            else {
+                index = this.m_sheet.cssRules.length;
+            }
+            this.m_rules.set(name, this.m_sheet.insertRule(definition, index));
+        }
+        else {
+            let idx = 1;
+            for (let r in definition) {
+                let rule = r + " { ", css = definition[r];
+                for (let i in css) {
+                    let values = css[i]; // this is an array !
+                    for (let j = 0; j < values.length; j++) {
+                        rule += i + ": " + values[j] + "; ";
+                    }
+                }
+                rule += '}';
+                //console.log( rule );
+                this.setRule(name + '--' + idx, rule);
+                idx++;
+            }
+        }
+    }
+    /**
+     * return the style variable value
+     * @param name - variable name
+     * @example
+     * ```
+     * let color = Component.getCss( ).getVar( 'button-color' );
+     * ```
+     */
+    static getVar(name) {
+        if (!Stylesheet.doc_style) {
+            Stylesheet.doc_style = getComputedStyle(x4document.documentElement);
+        }
+        if (name[0] != '-') {
+            name = '--' + name;
+        }
+        return Stylesheet.doc_style.getPropertyValue(name); // #999999
+    }
+    static guid = 1;
+    static doc_style;
+}
+/**
+ *  -- [ @CSSPARSER ] -----------------------------------------------------------------
+ *
+ * adaptation of jss-for-node-js
+ */
+export class CSSParser {
+    result = {};
+    parse(css) {
+        this.result = {};
+        this.parse_json('', css);
+        return CSSParser.mk_string(this.result);
+    }
+    static mk_string(rules) {
+        // output result:	
+        let ret = '';
+        for (let a in rules) {
+            let css = rules[a];
+            ret += a + " { ";
+            for (let i in css) {
+                let values = css[i]; // this is an array !
+                for (let j = 0; j < values.length; j++) {
+                    ret += i + ": " + values[j] + "; ";
+                }
+            }
+            ret += "}\n";
+        }
+        return ret;
+    }
+    parse_json(scope, css) {
+        if (scope && !this.result[scope]) {
+            this.result[scope] = {};
+        }
+        for (let property in css) {
+            let value = css[property];
+            if (isArray(value)) {
+                let values = value;
+                for (let i = 0; i < values.length; i++) {
+                    this.addProperty(scope, property, values[i]);
+                }
+            }
+            /*else if (value instanceof Color) {
+                this.addProperty(scope, property, value.toString());
+            }*/
+            else {
+                switch (typeof (value)) {
+                    case "number": {
+                        this.addProperty(scope, property, value);
+                        break;
+                    }
+                    case "string": {
+                        this.addProperty(scope, property, value);
+                        break;
+                    }
+                    case "object": {
+                        this.parse_json(this.makeSelectorName(scope, property), value);
+                        break;
+                    }
+                    default: {
+                        console.error("ignoring unknown type " + typeof (value) + " in property " + property);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    makePropertyName(n) {
+        return pascalCase(n);
+    }
+    makeSelectorName(scope, name) {
+        let snames = [];
+        let names = name.split(/\s*,\s*/);
+        let scopes = scope.split(/\s*,\s*/);
+        for (let s = 0; s < scopes.length; s++) {
+            let scope = scopes[s];
+            for (let i = 0; i < names.length; i++) {
+                let name = names[i], sub = false;
+                if (name.charAt(0) == "&") {
+                    name = name.substr(1);
+                    sub = true;
+                }
+                if (name.charAt(0) === '%') {
+                    name = '.o-' + name.substr(1);
+                }
+                if (sub) {
+                    snames.push(scope + name);
+                }
+                else {
+                    snames.push(scope ? scope + " " + name : name);
+                }
+            }
+        }
+        return snames.join(", ");
+    }
+    addProperty(scope, property, value) {
+        let properties = property.split(/\s*,\s*/);
+        for (let i = 0; i < properties.length; i++) {
+            let property = this.makePropertyName(properties[i]);
+            if (this.result[scope][property]) {
+                this.result[scope][property].push(value);
+            }
+            else {
+                this.result[scope][property] = [value];
+            }
+            let specials = {
+                "box-shadow": [
+                    "-moz-box-shadow",
+                    "-webkit-box-shadow"
+                ],
+                "border-radius": [
+                    "-moz-border-radius",
+                    "-webkit-border-radius"
+                ],
+                "border-radius-topleft": [
+                    "-moz-border-radius-topleft",
+                    "-webkit-border-top-left-radius"
+                ],
+                "border-radius-topright": [
+                    "-moz-border-radius-topright",
+                    "-webkit-border-top-right-radius"
+                ],
+                "border-radius-bottomleft": [
+                    "-moz-border-radius-bottomleft",
+                    "-webkit-border-bottom-left-radius"
+                ],
+                "border-radius-bottomright": [
+                    "-moz-border-radius-bottomright",
+                    "-webkit-border-bottom-right-radius"
+                ]
+            };
+            let browser_specials = specials[property];
+            for (let j = 0; browser_specials && j < browser_specials.length; j++) {
+                this.addProperty(scope, browser_specials[j], value);
+            }
+        }
+    }
+}
+export class ComputedStyle {
+    m_style;
+    constructor(style) {
+        this.m_style = style;
+    }
+    /**
+     * return the raw value
+     */
+    value(name) {
+        name = pascalCase(name);
+        return this.m_style[name];
+    }
+    /**
+     * return the interpreted value
+     */
+    parse(name) {
+        name = pascalCase(name);
+        return parseInt(this.m_style[name]);
+    }
+    /**
+     *
+     */
+    get style() {
+        return this.m_style;
+    }
+}

package/lib/esm/svgcomponent.d.ts

@@ -0,0 +1,191 @@
+/**
+*  ___   ___ __
+*  \  \_/  /  / _
+*   \     /  /_| |_
+*   /  _  \____   _|
+*  /__/ \__\   |_|
+*
+* @file svgcomponent.ts
+* @author Etienne Cochard
+*
+* Copyright (c) 2019-2022 R-libre ingenierie
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+* of the Software, and to permit persons to whom the Software is furnished to do so,
+* subject to the following conditions:
+* The above copyright notice and this permission notice shall be included in all copies
+* or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**/
+import { Component, CProps } from './component';
+/**
+ *
+ */
+declare abstract class SVGItem {
+    private m_tag;
+    private m_attrs;
+    private m_style;
+    constructor(tag: string);
+    /**
+     * render the item
+     * @returns
+     */
+    render(): string;
+    /**
+     * change the stroke color
+     * @param color
+     */
+    stroke(color: string, width?: number): this;
+    /**
+     * change the stroke width
+     * @param width
+     */
+    strokeWidth(width: number): this;
+    /**
+     * change the fill color
+     * @param color
+     */
+    fill(color: string): this;
+    /**
+     * define a new attribute
+     * @param name attibute name
+     * @param value attribute value
+     * @returns this
+     */
+    attr(name: string, value: string): this;
+    style(name: string, value: string | number): this;
+    /**
+     * add a class
+     * @param name class name to add
+     */
+    class(name: string): this;
+    /**
+     *
+     */
+    renderAttrs(): string;
+    /**
+     *
+     */
+    renderStyle(): string;
+    /**
+     *
+     */
+    renderContent(): string;
+    /**
+     *
+     */
+    clip(id: string): this;
+}
+/**
+ *
+ */
+declare class SVGPath extends SVGItem {
+    private m_path;
+    constructor();
+    renderAttrs(): string;
+    /**
+     * move the current pos
+     * @param x new pos x
+     * @param y new pos y
+     * @returns this
+     */
+    moveTo(x: number, y: number): this;
+    /**
+     * draw aline to the given point
+     * @param x end x
+     * @param y end y
+     * @returns this
+     */
+    lineTo(x: number, y: number): this;
+    /**
+     * close the currentPath
+     */
+    closePath(): this;
+    /**
+     * draw an arc
+     * @param x center x
+     * @param y center y
+     * @param r radius
+     * @param start angle start in degrees
+     * @param end angle end in degrees
+     * @returns this
+     */
+    arc(x: number, y: number, r: number, start: number, end: number): this;
+}
+/**
+ *
+ */
+declare class SVGText extends SVGItem {
+    private m_text;
+    constructor(x: number, y: number, txt: string);
+    font(font: string): this;
+    fontSize(size: number | string): this;
+    fontWeight(weight: 'light' | 'normal' | 'bold'): this;
+    textAlign(align: 'left' | 'center' | 'right'): this;
+    verticalAlign(align: 'top' | 'center' | 'bottom'): this;
+    renderContent(): any;
+}
+/**
+ *
+ */
+declare class SVGShape extends SVGItem {
+    constructor(tag: string);
+}
+/**
+ *
+ */
+declare class SVGGradient extends SVGItem {
+    private static g_id;
+    private m_id;
+    private m_stops;
+    constructor(x1: number, y1: number, x2: number, y2: number);
+    get id(): string;
+    addStop(offset: number, color: string): this;
+    renderContent(): string;
+}
+/**
+ *
+ */
+declare class SVGGroup extends SVGItem {
+    protected m_items: SVGItem[];
+    constructor(tag?: string);
+    path(): SVGPath;
+    text(x: any, y: any, txt: any): SVGText;
+    ellipse(x: any, y: any, r1: any, r2?: any): SVGShape;
+    rect(x: any, y: any, w: any, h: any): SVGShape;
+    gradient(x1: any, y1: any, x2: any, y2: any): SVGGradient;
+    /**
+     * clear
+     */
+    clear(): void;
+    renderContent(): string;
+}
+/**
+ *
+ */
+export declare class SVGPathBuilder extends SVGGroup {
+    private static g_clip_id;
+    constructor();
+    addClip(x: number, y: number, w: number, h: number): string;
+    render(): string;
+}
+/**
+ *
+ */
+export interface SVGProps extends CProps {
+    viewBox?: string;
+    path?: string;
+}
+export declare class SVGComponent<P extends SVGProps = SVGProps> extends Component<P> {
+    constructor(props: P);
+}
+export {};