TypeScript knockout.pureComputed函数代码示例

 export function createToggleButton(title = "Toggle") {
     const toggled = ko.observable(Math.random() >= 0.5);
     
     return {
         __: "button",
         title: ko.pureComputed(() => title + (toggled() ? " (on)" : " (off)")), 
         icon: getRandomIcon(),
         selected: toggled,
         click: function() { toggled(!toggled()); }
     };
 }

 constructor(public question: QuestionBase) {
     var self = this;
     question.visibilityChangedCallback = function () { self.onVisibilityChanged(); };
     question.renderWidthChangedCallback = function () { self.onRenderWidthChanged(); };
     this.koVisible = ko.observable(this.question.visible);
     this.koRenderWidth = ko.observable(this.question.renderWidth);
     this.koErrors = ko.observableArray();
     this.koMarginLeft = ko.pureComputed(function () { self.koRenderWidth(); return self.getIndentSize(self.question.indent); });
     this.koPaddingRight = ko.observable(self.getIndentSize(self.question.rightIndent));
     this.question["koVisible"] = this.koVisible;
     this.question["koRenderWidth"] = this.koRenderWidth;
     this.question["koErrors"] = this.koErrors;
     this.question["koMarginLeft"] = this.koMarginLeft;
     this.question["koPaddingRight"] = this.koPaddingRight;
 }

export function createComputedArray<T>(value: MaybeSubscribable<any[]>, mapFunction?: (obj: any) => T, context?: any): ko.PureComputed<T[]> {
    const cpArray = ko.pureComputed(() => {
        if (cpArray[OLD_VALUES_PROPERTY]) {
            cpArray[OLD_VALUES_PROPERTY].forEach(d => { 
                if (typeof d.dispose === "function") {
                    d.dispose();
                }
            });
        }
        
        const val = ko.unwrap(value);
        if (!Array.isArray(val)) {
            cpArray[OLD_VALUES_PROPERTY] = null;
            return [];
        }
        
        return cpArray[OLD_VALUES_PROPERTY] = val.map(mapFunction, context);
    });
    
    return cpArray;
}

export function unpromise<T>(evaluator: () => T | PromiseLike<T>, options?: UnpromiseOptions<T>): ko.PureComputed<T | undefined> {
    options = options || {};

    const
        latestValue = ko.observable(options.initialValue),
        errorValue = options.errorValue || options.initialValue,
        owner = options.owner,

        pureComputed = ko.pureComputed<T | undefined>(latestValue);

    let waitingOn = 0;

    purify(pureComputed, function () {
        var prom = evaluator.call(owner),
            current = ++waitingOn;

        if (isPromiseLike(prom)) {
            prom.then(
                res => {
                    if (current === waitingOn) {
                        latestValue(res);
                    }
                },
                () => {
                    if (current === waitingOn) {
                        latestValue(errorValue);
                    }
                });
        }
        else {
            latestValue(prom);
        }
    });

    return pureComputed;
}

 beforeEach(() => {
     obs = ko.observable("value");
     base = ko.pureComputed<number>(ko.observable(Math.random()));
 });

 constructor(data) {
     mapping.fromJS(data, {}, this);
     this.nameLength = ko.pureComputed(() => this.name().length, this);
 }