xhs-mp-pack 1.1.0-beta.0

package/dist/rules/BasicEffectRulePlugin.d.ts

@@ -0,0 +1,7 @@
+declare class BasicEffectRulePlugin {
+    ruleProperty: any;
+    effectType: any;
+    constructor(ruleProperty: any, effectType?: string);
+    apply(ruleSetCompiler: any): void;
+}
+export default BasicEffectRulePlugin;

package/dist/rules/BasicEffectRulePlugin.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class BasicEffectRulePlugin {
+    constructor(ruleProperty, effectType) {
+        this.ruleProperty = ruleProperty;
+        this.effectType = effectType || ruleProperty;
+    }
+    apply(ruleSetCompiler) {
+        ruleSetCompiler.hooks.rule.tap('BasicEffectRulePlugin', (path, rule, unhandledProperties, result, references) => {
+            if (unhandledProperties.has(this.ruleProperty)) {
+                unhandledProperties.delete(this.ruleProperty);
+                const value = rule[this.ruleProperty];
+                result.effects.push({
+                    type: this.effectType,
+                    value,
+                });
+            }
+        });
+    }
+}
+exports.default = BasicEffectRulePlugin;

package/dist/rules/BasicMatcherRulePlugin.d.ts

@@ -0,0 +1,8 @@
+declare class BasicMatcherRulePlugin {
+    ruleProperty: string;
+    dataProperty: string;
+    invert: boolean;
+    constructor(ruleProperty: string, dataProperty?: string, invert?: boolean);
+    apply(ruleSetCompiler: any): void;
+}
+export default BasicMatcherRulePlugin;

package/dist/rules/BasicMatcherRulePlugin.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class BasicMatcherRulePlugin {
+    constructor(ruleProperty, dataProperty, invert) {
+        this.ruleProperty = ruleProperty;
+        this.dataProperty = dataProperty || ruleProperty;
+        this.invert = invert || false;
+    }
+    apply(ruleSetCompiler) {
+        ruleSetCompiler.hooks.rule.tap('BasicMatcherRulePlugin', (path, rule, unhandledProperties, result) => {
+            if (unhandledProperties.has(this.ruleProperty)) {
+                unhandledProperties.delete(this.ruleProperty);
+                const value = rule[this.ruleProperty];
+                const condition = ruleSetCompiler.compileCondition(`${path}.${this.ruleProperty}`, value);
+                const fn = condition.fn;
+                result.conditions.push({
+                    property: this.dataProperty,
+                    matchWhenEmpty: this.invert ? !condition.matchWhenEmpty : condition.matchWhenEmpty,
+                    fn: this.invert ? v => !fn(v) : fn,
+                });
+            }
+        });
+    }
+}
+exports.default = BasicMatcherRulePlugin;

package/dist/rules/ObjectMatcherRulePlugin.d.ts

@@ -0,0 +1,7 @@
+declare class ObjectMatcherRulePlugin {
+    ruleProperty: any;
+    dataProperty: any;
+    constructor(ruleProperty: any, dataProperty?: any);
+    apply(ruleSetCompiler: any): void;
+}
+export default ObjectMatcherRulePlugin;

package/dist/rules/ObjectMatcherRulePlugin.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ObjectMatcherRulePlugin {
+    constructor(ruleProperty, dataProperty) {
+        this.ruleProperty = ruleProperty;
+        this.dataProperty = dataProperty || ruleProperty;
+    }
+    apply(ruleSetCompiler) {
+        const { ruleProperty, dataProperty } = this;
+        ruleSetCompiler.hooks.rule.tap('ObjectMatcherRulePlugin', (path, rule, unhandledProperties, result) => {
+            if (unhandledProperties.has(ruleProperty)) {
+                unhandledProperties.delete(ruleProperty);
+                const value = rule[ruleProperty];
+                for (const property of Object.keys(value)) {
+                    const nestedDataProperties = property.split('.');
+                    const condition = ruleSetCompiler.compileCondition(`${path}.${ruleProperty}.${property}`, value[property]);
+                    result.conditions.push({
+                        property: [dataProperty, ...nestedDataProperties],
+                        matchWhenEmpty: condition.matchWhenEmpty,
+                        fn: condition.fn,
+                    });
+                }
+            }
+        });
+    }
+}
+exports.default = ObjectMatcherRulePlugin;

package/dist/rules/RuleSetCompiler.d.ts

@@ -0,0 +1,20 @@
+declare class RuleSetCompiler {
+    hooks: any;
+    constructor(plugins: any);
+    compile(ruleSet: any): {
+        references: Map<any, any>;
+        exec: (data: any) => never[];
+    };
+    compileRules(path: any, rules: any, refs: any): any;
+    compileRule(path: any, rule: any, refs: any): {
+        conditions: never[];
+        effects: never[];
+        rules: undefined;
+        oneOf: undefined;
+    };
+    compileCondition(path: any, condition: any): any;
+    combineConditionsOr(conditions: any): any;
+    combineConditionsAnd(conditions: any): any;
+    error(path: any, value: any, message: any): Error;
+}
+export default RuleSetCompiler;

package/dist/rules/RuleSetCompiler.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tapable_1 = require("tapable");
+class RuleSetCompiler {
+    constructor(plugins) {
+        this.hooks = Object.freeze({
+            rule: new tapable_1.SyncHook([
+                'path',
+                'rule',
+                'unhandledProperties',
+                'compiledRule',
+                'references',
+            ]),
+        });
+        if (plugins) {
+            for (const plugin of plugins) {
+                plugin.apply(this);
+            }
+        }
+    }
+    compile(ruleSet) {
+        const refs = new Map();
+        const rules = this.compileRules('ruleSet', ruleSet, refs);
+        const execRule = (data, rule, effects) => {
+            for (const condition of rule.conditions) {
+                const p = condition.property;
+                if (Array.isArray(p)) {
+                    let current = data;
+                    for (const subProperty of p) {
+                        if (current &&
+                            typeof current === 'object' &&
+                            Object.prototype.hasOwnProperty.call(current, subProperty)) {
+                            current = current[subProperty];
+                        }
+                        else {
+                            current = undefined;
+                            break;
+                        }
+                    }
+                    if (current !== undefined) {
+                        if (!condition.fn(current))
+                            return false;
+                        continue;
+                    }
+                }
+                else if (p in data) {
+                    const value = data[p];
+                    if (value !== undefined) {
+                        if (!condition.fn(value))
+                            return false;
+                        continue;
+                    }
+                }
+                if (!condition.matchWhenEmpty) {
+                    return false;
+                }
+            }
+            for (const effect of rule.effects) {
+                if (typeof effect === 'function') {
+                    const returnedEffects = effect(data);
+                    for (const effect of returnedEffects) {
+                        effects.push(effect);
+                    }
+                }
+                else {
+                    effects.push(effect);
+                }
+            }
+            if (rule.rules) {
+                for (const childRule of rule.rules) {
+                    execRule(data, childRule, effects);
+                }
+            }
+            if (rule.oneOf) {
+                for (const childRule of rule.oneOf) {
+                    if (execRule(data, childRule, effects)) {
+                        break;
+                    }
+                }
+            }
+            return true;
+        };
+        return {
+            references: refs,
+            exec: data => {
+                const effects = [];
+                for (const rule of rules) {
+                    execRule(data, rule, effects);
+                }
+                return effects;
+            },
+        };
+    }
+    compileRules(path, rules, refs) {
+        return rules.filter(Boolean).map((rule, i) => this.compileRule(`${path}[${i}]`, rule, refs));
+    }
+    compileRule(path, rule, refs) {
+        const unhandledProperties = new Set(Object.keys(rule).filter(key => rule[key] !== undefined));
+        const compiledRule = {
+            conditions: [],
+            effects: [],
+            rules: undefined,
+            oneOf: undefined,
+        };
+        this.hooks.rule.call(path, rule, unhandledProperties, compiledRule, refs);
+        if (unhandledProperties.has('rules')) {
+            unhandledProperties.delete('rules');
+            const rules = rule.rules;
+            if (!Array.isArray(rules))
+                throw this.error(path, rules, 'Rule.rules must be an array of rules');
+            compiledRule.rules = this.compileRules(`${path}.rules`, rules, refs);
+        }
+        if (unhandledProperties.has('oneOf')) {
+            unhandledProperties.delete('oneOf');
+            const oneOf = rule.oneOf;
+            if (!Array.isArray(oneOf))
+                throw this.error(path, oneOf, 'Rule.oneOf must be an array of rules');
+            compiledRule.oneOf = this.compileRules(`${path}.oneOf`, oneOf, refs);
+        }
+        if (unhandledProperties.size > 0) {
+            throw this.error(path, rule, `Properties ${Array.from(unhandledProperties).join(', ')} are unknown`);
+        }
+        return compiledRule;
+    }
+    compileCondition(path, condition) {
+        if (condition === '') {
+            return {
+                matchWhenEmpty: true,
+                fn: str => str === '',
+            };
+        }
+        if (!condition) {
+            throw this.error(path, condition, 'Expected condition but got falsy value');
+        }
+        if (typeof condition === 'string') {
+            return {
+                matchWhenEmpty: condition.length === 0,
+                fn: str => typeof str === 'string' && str.startsWith(condition),
+            };
+        }
+        if (typeof condition === 'function') {
+            try {
+                return {
+                    matchWhenEmpty: condition(''),
+                    fn: condition,
+                };
+            }
+            catch (err) {
+                throw this.error(path, condition, 'Evaluation of condition function threw error');
+            }
+        }
+        if (condition instanceof RegExp) {
+            return {
+                matchWhenEmpty: condition.test(''),
+                fn: v => typeof v === 'string' && condition.test(v),
+            };
+        }
+        if (Array.isArray(condition)) {
+            const items = condition.map((c, i) => this.compileCondition(`${path}[${i}]`, c));
+            return this.combineConditionsOr(items);
+        }
+        if (typeof condition !== 'object') {
+            throw this.error(path, condition, `Unexpected ${typeof condition} when condition was expected`);
+        }
+        const conditions = [];
+        for (const key of Object.keys(condition)) {
+            const value = condition[key];
+            switch (key) {
+                case 'or':
+                    if (value) {
+                        if (!Array.isArray(value)) {
+                            throw this.error(`${path}.or`, condition.and, 'Expected array of conditions');
+                        }
+                        conditions.push(this.compileCondition(`${path}.or`, value));
+                    }
+                    break;
+                case 'and':
+                    if (value) {
+                        if (!Array.isArray(value)) {
+                            throw this.error(`${path}.and`, condition.and, 'Expected array of conditions');
+                        }
+                        let i = 0;
+                        for (const item of value) {
+                            conditions.push(this.compileCondition(`${path}.and[${i}]`, item));
+                            i++;
+                        }
+                    }
+                    break;
+                case 'not':
+                    if (value) {
+                        const matcher = this.compileCondition(`${path}.not`, value);
+                        const fn = matcher.fn;
+                        conditions.push({
+                            matchWhenEmpty: !matcher.matchWhenEmpty,
+                            fn: v => !fn(v),
+                        });
+                    }
+                    break;
+                default:
+                    throw this.error(`${path}.${key}`, condition[key], `Unexpected property ${key} in condition`);
+            }
+        }
+        if (conditions.length === 0) {
+            throw this.error(path, condition, 'Expected condition, but got empty thing');
+        }
+        return this.combineConditionsAnd(conditions);
+    }
+    combineConditionsOr(conditions) {
+        if (conditions.length === 0) {
+            return {
+                matchWhenEmpty: false,
+                fn: () => false,
+            };
+        }
+        if (conditions.length === 1) {
+            return conditions[0];
+        }
+        return {
+            matchWhenEmpty: conditions.some(c => c.matchWhenEmpty),
+            fn: v => conditions.some(c => c.fn(v)),
+        };
+    }
+    combineConditionsAnd(conditions) {
+        if (conditions.length === 0) {
+            return {
+                matchWhenEmpty: false,
+                fn: () => false,
+            };
+        }
+        if (conditions.length === 1) {
+            return conditions[0];
+        }
+        return {
+            matchWhenEmpty: conditions.every(c => c.matchWhenEmpty),
+            fn: v => conditions.every(c => c.fn(v)),
+        };
+    }
+    error(path, value, message) {
+        return new Error(`Compiling RuleSet failed: ${message} (at ${path}: ${value})`);
+    }
+}
+exports.default = RuleSetCompiler;

package/dist/rules/UseEffectRulePlugin.d.ts

@@ -0,0 +1,5 @@
+declare class UseEffectRulePlugin {
+    apply(ruleSetCompiler: any): void;
+    useItemToEffects(path: any, item: any): void;
+}
+export default UseEffectRulePlugin;

package/dist/rules/UseEffectRulePlugin.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = __importDefault(require("util"));
+class UseEffectRulePlugin {
+    apply(ruleSetCompiler) {
+        ruleSetCompiler.hooks.rule.tap('UseEffectRulePlugin', (path, rule, unhandledProperties, result, references) => {
+            const conflictWith = (property, correctProperty) => {
+                if (unhandledProperties.has(property)) {
+                    throw ruleSetCompiler.error(`${path}.${property}`, rule[property], `A Rule must not have a '${property}' property when it has a '${correctProperty}' property`);
+                }
+            };
+            if (unhandledProperties.has('use')) {
+                unhandledProperties.delete('use');
+                unhandledProperties.delete('enforce');
+                conflictWith('loader', 'use');
+                conflictWith('options', 'use');
+                const use = rule.use;
+                const enforce = rule.enforce;
+                const type = enforce ? `use-${enforce}` : 'use';
+                const useToEffect = (path, defaultIdent, item) => {
+                    if (typeof item === 'function') {
+                        return data => useToEffectsWithoutIdent(path, item(data));
+                    }
+                    return useToEffectRaw(path, defaultIdent, item);
+                };
+                const useToEffectRaw = (path, defaultIdent, item) => {
+                    if (typeof item === 'string') {
+                        return {
+                            type,
+                            value: {
+                                loader: item,
+                                options: undefined,
+                                ident: undefined,
+                            },
+                        };
+                    }
+                    const loader = item.loader;
+                    const options = item.options;
+                    let ident = item.ident;
+                    if (options && typeof options === 'object') {
+                        if (!ident)
+                            ident = defaultIdent;
+                        references.set(ident, options);
+                    }
+                    if (typeof options === 'string') {
+                        util_1.default.deprecate(() => { }, `Using a string as loader options is deprecated (${path}.options)`, 'DEP_WEBPACK_RULE_LOADER_OPTIONS_STRING')();
+                    }
+                    return {
+                        type: enforce ? `use-${enforce}` : 'use',
+                        value: {
+                            loader,
+                            options,
+                            ident,
+                        },
+                    };
+                };
+                const useToEffectsWithoutIdent = (path, items) => {
+                    if (Array.isArray(items)) {
+                        return items
+                            .filter(Boolean)
+                            .map((item, idx) => useToEffectRaw(`${path}[${idx}]`, '[[missing ident]]', item));
+                    }
+                    return [useToEffectRaw(path, '[[missing ident]]', items)];
+                };
+                const useToEffects = (path, items) => {
+                    if (Array.isArray(items)) {
+                        return items.filter(Boolean).map((item, idx) => {
+                            const subPath = `${path}[${idx}]`;
+                            return useToEffect(subPath, subPath, item);
+                        });
+                    }
+                    return [useToEffect(path, path, items)];
+                };
+                if (typeof use === 'function') {
+                    result.effects.push(data => useToEffectsWithoutIdent(`${path}.use`, use(data)));
+                }
+                else {
+                    for (const effect of useToEffects(`${path}.use`, use)) {
+                        result.effects.push(effect);
+                    }
+                }
+            }
+            if (unhandledProperties.has('loader')) {
+                unhandledProperties.delete('loader');
+                unhandledProperties.delete('options');
+                unhandledProperties.delete('enforce');
+                const loader = rule.loader;
+                const options = rule.options;
+                const enforce = rule.enforce;
+                if (loader.includes('!')) {
+                    throw ruleSetCompiler.error(`${path}.loader`, loader, "Exclamation mark separated loader lists has been removed in favor of the 'use' property with arrays");
+                }
+                if (loader.includes('?')) {
+                    throw ruleSetCompiler.error(`${path}.loader`, loader, "Query arguments on 'loader' has been removed in favor of the 'options' property");
+                }
+                if (typeof options === 'string') {
+                    util_1.default.deprecate(() => { }, `Using a string as loader options is deprecated (${path}.options)`, 'DEP_WEBPACK_RULE_LOADER_OPTIONS_STRING')();
+                }
+                const ident = options && typeof options === 'object' ? path : undefined;
+                references.set(ident, options);
+                result.effects.push({
+                    type: enforce ? `use-${enforce}` : 'use',
+                    value: {
+                        loader,
+                        options,
+                        ident,
+                    },
+                });
+            }
+        });
+    }
+    useItemToEffects(path, item) { }
+}
+exports.default = UseEffectRulePlugin;

package/dist/serialization/Serialization.d.ts

@@ -0,0 +1,11 @@
+declare const _default: {
+    readonly register: any;
+    readonly registerLoader: any;
+    readonly registerNotSerializable: any;
+    readonly NOT_SERIALIZABLE: any;
+    readonly MEASURE_START_OPERATION: any;
+    readonly MEASURE_END_OPERATION: any;
+    readonly buffersSerializer: any;
+    createFileSerializer: (fs: any, hashFunction: any) => any;
+};
+export default _default;

package/dist/serialization/Serialization.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const memoize_1 = __importDefault(require("../base/memoize"));
+const getBinaryMiddleware = (0, memoize_1.default)(() => require('@/serialization/middlewares/BinaryMiddleware').default);
+const getObjectMiddleware = (0, memoize_1.default)(() => require('@/serialization/middlewares/ObjectMiddleware').default);
+const getSingleItemMiddleware = (0, memoize_1.default)(() => require('@/serialization/middlewares/SingleItemMiddleware').default);
+const getSerializer = (0, memoize_1.default)(() => require('@/serialization/Serializer').default);
+const getSerializerMiddleware = (0, memoize_1.default)(() => require('@/serialization/SerializerMiddleware').default);
+const getBinaryMiddlewareInstance = (0, memoize_1.default)(() => new (getBinaryMiddleware())());
+const registerSerializers = (0, memoize_1.default)(() => {
+    require('./registerExternalSerializer');
+    const internalSerializables = require('@/serialization/internalSerializables').default;
+    getObjectMiddleware().registerLoader(/^mp-compiler\//, req => {
+        const loader = internalSerializables[req.slice('mp-compiler/'.length)];
+        if (loader) {
+            loader();
+        }
+        else {
+            console.warn(`${req} not found in internalSerializables`);
+        }
+        return true;
+    });
+});
+let buffersSerializer;
+// Expose serialization API
+exports.default = {
+    get register() {
+        return getObjectMiddleware().register;
+    },
+    get registerLoader() {
+        return getObjectMiddleware().registerLoader;
+    },
+    get registerNotSerializable() {
+        return getObjectMiddleware().registerNotSerializable;
+    },
+    get NOT_SERIALIZABLE() {
+        return getObjectMiddleware().NOT_SERIALIZABLE;
+    },
+    get MEASURE_START_OPERATION() {
+        return getBinaryMiddleware().MEASURE_START_OPERATION;
+    },
+    get MEASURE_END_OPERATION() {
+        return getBinaryMiddleware().MEASURE_END_OPERATION;
+    },
+    get buffersSerializer() {
+        if (buffersSerializer !== undefined)
+            return buffersSerializer;
+        registerSerializers();
+        const Serializer = getSerializer();
+        const binaryMiddleware = getBinaryMiddlewareInstance();
+        const SerializerMiddleware = getSerializerMiddleware();
+        const SingleItemMiddleware = getSingleItemMiddleware();
+        buffersSerializer = new Serializer([
+            new SingleItemMiddleware(),
+            new (getObjectMiddleware())(context => {
+                if (context.write) {
+                    context.writeLazy = value => {
+                        context.write(SerializerMiddleware.createLazy(value, binaryMiddleware));
+                    };
+                }
+            }, 'md4'),
+            binaryMiddleware,
+        ]);
+        return buffersSerializer;
+    },
+    createFileSerializer: (fs, hashFunction) => {
+        registerSerializers();
+        const Serializer = getSerializer();
+        const FileMiddleware = require('@/serialization/middlewares/FileMiddleware');
+        const fileMiddleware = new FileMiddleware(fs, hashFunction);
+        const binaryMiddleware = getBinaryMiddlewareInstance();
+        const SerializerMiddleware = getSerializerMiddleware();
+        const SingleItemMiddleware = getSingleItemMiddleware();
+        return new Serializer([
+            new SingleItemMiddleware(),
+            new (getObjectMiddleware())(context => {
+                if (context.write) {
+                    context.writeLazy = value => {
+                        context.write(SerializerMiddleware.createLazy(value, binaryMiddleware));
+                    };
+                    context.writeSeparate = (value, options) => {
+                        const lazy = SerializerMiddleware.createLazy(value, fileMiddleware, options);
+                        context.write(lazy);
+                        return lazy;
+                    };
+                }
+            }, hashFunction),
+            binaryMiddleware,
+            fileMiddleware,
+        ]);
+    },
+};

package/dist/serialization/Serializer.d.ts

@@ -0,0 +1,9 @@
+declare class Serializer {
+    serializeMiddlewares: any;
+    deserializeMiddlewares: any;
+    context: any;
+    constructor(middlewares: any, context?: {});
+    serialize(obj: any, context: any): any;
+    deserialize(value: any, context: any): any;
+}
+export default Serializer;

package/dist/serialization/Serializer.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Serializer {
+    constructor(middlewares, context = {}) {
+        this.serializeMiddlewares = middlewares.slice();
+        this.deserializeMiddlewares = middlewares.slice().reverse();
+        this.context = context;
+    }
+    serialize(obj, context) {
+        const ctx = Object.assign(Object.assign({}, context), this.context);
+        let current = obj;
+        for (const middleware of this.serializeMiddlewares) {
+            if (current && typeof current.then === 'function') {
+                current = current.then(data => data && middleware.serialize(data, ctx));
+            }
+            else if (current) {
+                try {
+                    current = middleware.serialize(current, ctx);
+                }
+                catch (err) {
+                    current = Promise.reject(err);
+                }
+            }
+            else
+                break;
+        }
+        return current;
+    }
+    deserialize(value, context) {
+        const ctx = Object.assign(Object.assign({}, context), this.context);
+        let current = value;
+        for (const middleware of this.deserializeMiddlewares) {
+            if (current && typeof current.then === 'function') {
+                current = current.then(data => middleware.deserialize(data, ctx));
+            }
+            else {
+                current = middleware.deserialize(current, ctx);
+            }
+        }
+        return current;
+    }
+}
+exports.default = Serializer;

package/dist/serialization/SerializerMiddleware.d.ts

@@ -0,0 +1,13 @@
+declare class SerializerMiddleware {
+    serialize(data: any, context: any): void;
+    deserialize(data: any, context: any): void;
+    static createLazy(value: any, target: any, options?: {}, serializedValue?: any): any;
+    static isLazy(fn: any, target?: any): boolean;
+    static getLazyOptions(fn: any): any;
+    static getLazySerializedValue(fn: any): any;
+    static setLazySerializedValue(fn: any, value: any): void;
+    static serializeLazy(lazy: any, serialize: any): any;
+    static deserializeLazy(lazy: any, deserialize: any): any;
+    static unMemoizeLazy(lazy: any): any;
+}
+export default SerializerMiddleware;