How to use intersection method in storybook-root

Best JavaScript code snippet using storybook-root

test-intersection-observer.js

Source:test-intersection-observer.js

1/**2 * Copyright 2020 The AMP HTML Authors. All Rights Reserved.3 *4 * Licensed under the Apache License, Version 2.0 (the "License");5 * you may not use this file except in compliance with the License.6 * You may obtain a copy of the License at7 *8 *      http://www.apache.org/licenses/LICENSE-2.09 *10 * Unless required by applicable law or agreed to in writing, software11 * distributed under the License is distributed on an "AS-IS" BASIS,12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.13 * See the License for the specific language governing permissions and14 * limitations under the License.15 */16import {17  IntersectionObserverStub,18  resetSubsForTesting,19  shouldLoadPolyfill,20  upgradePolyfill,21} from '../../../src/polyfillstub/intersection-observer-stub';22import {23  install,24  installForChildWin,25} from '../../../src/polyfills/intersection-observer';26class NativeIntersectionObserver {27  constructor(callback, options) {28    this.callback = callback;29    this.options = options;30  }31  get root() {32    return 'native.root';33  }34  get rootMargin() {35    return 'native.rootMargin';36  }37  get thresholds() {38    return 'native.thresholds';39  }40  takeRecords() {41    return 'native.takeRecords';42  }43  observe() {}44  unobserve() {}45  disconnect() {}46}47class NativeIntersectionObserverEntry {48  get isIntersecting() {}49}50describes.sandboxed('shouldLoadPolyfill', {}, () => {51  it('should not load with native', () => {52    const win = {53      IntersectionObserver: NativeIntersectionObserver,54      IntersectionObserverEntry: NativeIntersectionObserverEntry,55    };56    expect(shouldLoadPolyfill(win)).to.be.false;57  });58  it('should load when no native', () => {59    const win = {};60    expect(shouldLoadPolyfill(win)).to.be.true;61  });62  it('should load with the stub', () => {63    const win = {64      IntersectionObserver: IntersectionObserverStub,65      IntersectionObserverEntry: NativeIntersectionObserverEntry,66    };67    expect(shouldLoadPolyfill(win)).to.be.true;68  });69  it('should load when no native entry', () => {70    const win = {71      IntersectionObserver: NativeIntersectionObserver,72    };73    expect(shouldLoadPolyfill(win)).to.be.true;74  });75  it('should not load even if entry doesn not have isIntersecting', () => {76    class IntersectionObserverEntryWithMissingIsIntersecting {}77    const win = {78      IntersectionObserver: NativeIntersectionObserver,79      IntersectionObserverEntry: IntersectionObserverEntryWithMissingIsIntersecting,80    };81    expect(shouldLoadPolyfill(win)).to.be.false;82  });83});84describes.fakeWin('install', {}, (env) => {85  it('should install IntersectionObserverStub when no native', () => {86    const {win} = env;87    delete win.IntersectionObserver;88    install(win);89    expect(win.IntersectionObserver).to.equal(IntersectionObserverStub);90  });91  it('should keep native when available', () => {92    const {win} = env;93    const native = function () {};94    win.IntersectionObserver = native;95    install(win);96    expect(win.IntersectionObserver).to.equal(native);97  });98  it('should polyfill isIntersecting when absent in native', () => {99    const {win} = env;100    const native = function () {};101    const nativeEntry = function () {};102    win.IntersectionObserver = native;103    win.IntersectionObserverEntry = nativeEntry;104    expect('isIntersecting' in win.IntersectionObserverEntry.prototype).to.be105      .false;106    install(win);107    expect(win.IntersectionObserver).to.equal(native);108    expect(win.IntersectionObserverEntry).to.equal(nativeEntry);109    expect('isIntersecting' in win.IntersectionObserverEntry.prototype).to.be110      .true;111    const entry = new win.IntersectionObserverEntry();112    expect(entry).to.be.instanceOf(nativeEntry);113    entry.intersectionRatio = 0;114    expect(entry.isIntersecting).to.be.false;115    entry.intersectionRatio = 1;116    expect(entry.isIntersecting).to.be.true;117  });118  it('should keep native isIntersecting when available', () => {119    const {win} = env;120    const native = function () {};121    const nativeEntry = function () {};122    Object.defineProperty(nativeEntry.prototype, 'isIntersecting', {123      value: 'A',124    });125    win.IntersectionObserver = native;126    win.IntersectionObserverEntry = nativeEntry;127    expect('isIntersecting' in win.IntersectionObserverEntry.prototype).to.be128      .true;129    install(win);130    const entry = new win.IntersectionObserverEntry();131    expect(entry).to.be.instanceOf(nativeEntry);132    entry.intersectionRatio = 0;133    expect(entry.isIntersecting).to.equal('A');134    entry.intersectionRatio = 1;135    expect(entry.isIntersecting).to.equal('A');136  });137});138describes.fakeWin('installForChildWin', {}, (env) => {139  const IntersectionObserver1 = function () {};140  const IntersectionObserverEntry1 = function () {};141  const IntersectionObserver2 = function () {};142  const IntersectionObserverEntry2 = function () {};143  it('should install IntersectionObserverStub when no native', () => {144    const {win} = env;145    delete win.IntersectionObserver;146    const parentWin = {147      IntersectionObserver: IntersectionObserver1,148      IntersectionObserverEntry: IntersectionObserverEntry1,149    };150    installForChildWin(parentWin, win);151    expect(win.IntersectionObserver).to.equal(IntersectionObserver1);152    expect(win.IntersectionObserverEntry).to.equal(IntersectionObserverEntry1);153    // Change parent.154    parentWin.IntersectionObserver = IntersectionObserver2;155    parentWin.IntersectionObserverEntry = IntersectionObserverEntry2;156    expect(win.IntersectionObserver).to.equal(IntersectionObserver2);157    expect(win.IntersectionObserverEntry).to.equal(IntersectionObserverEntry2);158  });159  it('should keep native when available', () => {160    const {win} = env;161    const native = function () {};162    const nativeEntry = function () {};163    win.IntersectionObserver = native;164    win.IntersectionObserverEntry = nativeEntry;165    const parentWin = {166      IntersectionObserver: IntersectionObserver1,167      IntersectionObserverEntry: IntersectionObserverEntry1,168    };169    installForChildWin(parentWin, win);170    expect(win.IntersectionObserver).to.equal(native);171    expect(win.IntersectionObserverEntry).to.equal(nativeEntry);172  });173});174describes.fakeWin('upgradePolyfill', {}, (env) => {175  beforeEach(() => {176    env.sandbox.stub(NativeIntersectionObserver.prototype, 'observe');177    env.sandbox.stub(NativeIntersectionObserver.prototype, 'disconnect');178  });179  afterEach(() => {180    resetSubsForTesting();181  });182  function nextMicroTask() {183    return Promise.resolve().then(() => Promise.resolve());184  }185  it('should reset stub before running the installer', () => {186    const {win} = env;187    delete win.IntersectionObserver;188    install(win);189    expect(win.IntersectionObserver).to.equal(IntersectionObserverStub);190    upgradePolyfill(win, function () {191      expect(win.IntersectionObserver).to.not.be.ok;192      expect(win.IntersectionObserverEntry).to.not.be.ok;193    });194  });195  it('should upgrade all stubs', async () => {196    const {win} = env;197    delete win.IntersectionObserver;198    install(win);199    const callback = function () {};200    const element1 = win.document.createElement('div');201    const io1 = new win.IntersectionObserver(callback);202    const io2 = new win.IntersectionObserver(callback);203    expect(io1).to.be.instanceOf(IntersectionObserverStub);204    expect(io2).to.be.instanceOf(IntersectionObserverStub);205    io1.observe(element1);206    io2.observe(element1);207    expect(NativeIntersectionObserver.prototype.observe).to.not.be.called;208    upgradePolyfill(win, function () {209      win.IntersectionObserver = NativeIntersectionObserver;210      win.IntersectionObserverEntry = NativeIntersectionObserverEntry;211    });212    await nextMicroTask();213    expect(NativeIntersectionObserver.prototype.observe).to.be.calledTwice;214    expect(NativeIntersectionObserver.prototype.observe).to.be.calledWith(215      element1216    );217    expect(NativeIntersectionObserver.prototype.disconnect).to.not.be.called;218    io1.disconnect();219    io2.disconnect();220    expect(NativeIntersectionObserver.prototype.disconnect).to.be.calledTwice;221  });222  it('should auto-upgrade any stub post upgrade', async () => {223    const {win} = env;224    delete win.IntersectionObserver;225    install(win);226    expect(win.IntersectionObserver).to.equal(IntersectionObserverStub);227    upgradePolyfill(win, function () {228      win.IntersectionObserver = NativeIntersectionObserver;229      win.IntersectionObserverEntry = NativeIntersectionObserverEntry;230    });231    const callback = function () {};232    const element1 = win.document.createElement('div');233    const io = new IntersectionObserverStub(callback);234    await nextMicroTask();235    io.observe(element1);236    expect(NativeIntersectionObserver.prototype.observe).to.be.calledOnce;237    expect(NativeIntersectionObserver.prototype.observe).to.be.calledWith(238      element1239    );240  });241  it('should run installer even when native is available', () => {242    const {win} = env;243    win.IntersectionObserver = NativeIntersectionObserver;244    win.IntersectionObserverEntry = NativeIntersectionObserverEntry;245    const upgradeCall = env.sandbox.spy();246    upgradePolyfill(win, function () {247      expect(win.IntersectionObserver).to.equal(NativeIntersectionObserver);248      expect(win.IntersectionObserverEntry).to.equal(249        NativeIntersectionObserverEntry250      );251      upgradeCall();252    });253    expect(upgradeCall).to.be.calledOnce;254  });255});256describes.fakeWin('IntersectionObserverStub', {}, (env) => {257  let win;258  let callback;259  let element1;260  let element2;261  beforeEach(() => {262    win = env.win;263    callback = env.sandbox.spy();264    element1 = win.document.createElement('div');265    element2 = win.document.createElement('div');266  });267  describe('constructor', () => {268    it('should disallow non-element root', () => {269      // Must fail on any non-element root. This is critical because this270      // failure is used as a feature-detection for document root support.271      expect(272        () => new IntersectionObserverStub(callback, {root: win.document})273      ).to.throw(/root must be an Element/);274    });275    it('should allow default options', () => {276      const io = new IntersectionObserverStub(callback);277      expect(io.root).to.be.null;278      expect(io.rootMargin).to.equal('0px 0px 0px 0px');279      expect(io.thresholds).to.deep.equal([0]);280    });281    it('should allow null root', () => {282      const io = new IntersectionObserverStub(callback, {root: null});283      expect(io.root).to.be.null;284      expect(io.rootMargin).to.equal('0px 0px 0px 0px');285      expect(io.thresholds).to.deep.equal([0]);286    });287    it('should allow element root', () => {288      const element = win.document.createElement('div');289      const io = new IntersectionObserverStub(callback, {root: element});290      expect(io.root).to.equal(element);291    });292    it('should override rootMargin', () => {293      const io = new IntersectionObserverStub(callback, {rootMargin: '10px'});294      expect(io.rootMargin).to.equal('10px');295    });296    it('should override threshold as number', () => {297      const io = new IntersectionObserverStub(callback, {threshold: 0.1});298      expect(io.thresholds).to.deep.equal([0.1]);299    });300    it('should override threshold as array', () => {301      const io = new IntersectionObserverStub(callback, {302        threshold: [0.1, 0.2],303      });304      expect(io.thresholds).to.deep.equal([0.1, 0.2]);305    });306  });307  describe('takeRecords', () => {308    it('should always be empty', () => {309      const io = new IntersectionObserverStub(callback);310      expect(io.takeRecords()).to.deep.equal([]);311    });312  });313  describe('observe/unobserve/disconnect', () => {314    it('should queue up elements when observed, but only once', () => {315      const io = new IntersectionObserverStub(callback);316      io.observe(element1);317      expect(io.elements_).to.deep.equal([element1]);318      io.observe(element1);319      expect(io.elements_).to.deep.equal([element1]);320      io.observe(element2);321      expect(io.elements_).to.deep.equal([element1, element2]);322    });323    it('should dequeue elements when observed', () => {324      const io = new IntersectionObserverStub(callback);325      io.observe(element1);326      io.observe(element2);327      expect(io.elements_).to.deep.equal([element1, element2]);328      io.unobserve(element1);329      expect(io.elements_).to.deep.equal([element2]);330      io.unobserve(element2);331      expect(io.elements_).to.deep.equal([]);332      io.unobserve(element1);333      io.unobserve(element2);334      expect(io.elements_).to.deep.equal([]);335    });336    it('should dequeue elements when disconnected', () => {337      const io = new IntersectionObserverStub(callback);338      io.observe(element1);339      io.observe(element2);340      expect(io.elements_).to.deep.equal([element1, element2]);341      io.disconnect();342      expect(io.elements_).to.deep.equal([]);343      io.disconnect();344      expect(io.elements_).to.deep.equal([]);345    });346  });347  describe('upgrade', () => {348    beforeEach(() => {349      env.sandbox.stub(NativeIntersectionObserver.prototype, 'observe');350      env.sandbox.stub(NativeIntersectionObserver.prototype, 'unobserve');351      env.sandbox.stub(NativeIntersectionObserver.prototype, 'disconnect');352    });353    function upgrade(io) {354      io.upgrade_(NativeIntersectionObserver);355      return io.inst_;356    }357    it('should forward callback and default options', () => {358      const io = new IntersectionObserverStub(callback);359      const native = upgrade(io);360      expect(native.callback).to.equal(callback);361      expect(native.options).to.deep.equal({362        root: null,363        rootMargin: '0px 0px 0px 0px',364      });365    });366    it('should forward custom options', () => {367      const io = new IntersectionObserverStub(callback, {368        root: element1,369        rootMargin: '10px',370        threshold: 0.1,371      });372      const native = upgrade(io);373      expect(native.options).to.deep.equal({374        root: element1,375        rootMargin: '10px',376        threshold: 0.1,377      });378    });379    it('should delegate getters to the native', () => {380      const io = new IntersectionObserverStub(callback);381      upgrade(io);382      expect(io.root).to.equal('native.root');383      expect(io.rootMargin).to.equal('native.rootMargin');384      expect(io.thresholds).to.equal('native.thresholds');385      expect(io.takeRecords()).to.equal('native.takeRecords');386    });387    it('should not re-queue if nothing is currently observed', () => {388      const io = new IntersectionObserverStub(callback);389      io.observe(element1);390      io.unobserve(element1);391      const native = upgrade(io);392      expect(native.observe).to.not.be.called;393      expect(io.elements_).to.be.null;394    });395    it('should re-queue previously observed elements', () => {396      const io = new IntersectionObserverStub(callback);397      io.observe(element1);398      io.observe(element2);399      const native = upgrade(io);400      expect(native.observe).to.be.calledTwice;401      expect(native.observe).to.be.calledWith(element1);402      expect(native.observe).to.be.calledWith(element2);403      expect(io.elements_).to.be.null;404    });405    it('should observe new elements only on native', () => {406      const io = new IntersectionObserverStub(callback);407      const native = upgrade(io);408      io.observe(element1);409      expect(native.observe).to.be.calledOnce.calledWith(element1);410    });411    it('should unobserve new elements only on native', () => {412      const io = new IntersectionObserverStub(callback);413      const native = upgrade(io);414      io.unobserve(element1);415      expect(native.unobserve).to.be.calledOnce.calledWith(element1);416    });417    it('should disconnect on native', () => {418      const io = new IntersectionObserverStub(callback);419      const native = upgrade(io);420      io.disconnect();421      expect(native.disconnect).to.be.calledOnce;422    });423  });...

intersection.js

Source:intersection.js

1(function() {2  QUnit.module('fabric.Intersection');3  QUnit.test('constructor & properties', function(assert) {4    assert.ok(typeof fabric.Intersection === 'function');5    var intersection = new fabric.Intersection();6    assert.ok(intersection);7    assert.ok(intersection instanceof fabric.Intersection);8    assert.ok(intersection.constructor === fabric.Intersection);9    assert.ok(typeof intersection.constructor === 'function');10    assert.deepEqual(intersection.points, [], 'starts with empty array of points');11    assert.ok('status' in intersection, 'has status property');12    assert.equal(intersection.status, undefined, 'no default value for status');13    var status = 'status';14    intersection = new fabric.Intersection(status);15    assert.equal(intersection.status, status, 'constructor pass status value');16  });17  QUnit.test('appendPoint', function(assert) {18    var point = new fabric.Point(1, 1);19    var intersection = new fabric.Intersection();20    assert.ok(typeof intersection.appendPoint === 'function', 'has appendPoint method');21    var returned = intersection.appendPoint(point);22    assert.ok(returned instanceof fabric.Intersection, 'returns a fabric.Intersection');23    assert.equal(returned, intersection, 'is chainable');24    assert.equal(intersection.points.indexOf(point), 0, 'now intersection contain points');25  });26  QUnit.test('appendPoints', function(assert) {27    var point = new fabric.Point(1, 1);28    var intersection = new fabric.Intersection();29    assert.ok(typeof intersection.appendPoints === 'function', 'has appendPoint method');30    var returned = intersection.appendPoints([point, point]);31    assert.ok(returned instanceof fabric.Intersection, 'returns a fabric.Intersection');32    assert.equal(returned, intersection, 'is chainable');33    assert.equal(intersection.points.indexOf(point), 0, 'now intersection contain points');34    assert.equal(intersection.points.length, 2, 'now intersection contains 2 points');35  });36  QUnit.test('intersectLineLine simple intersection', function(assert) {37    var p1 = new fabric.Point(0, 0), p2 = new fabric.Point(10,10),38        p3 = new fabric.Point(0, 10), p4 = new fabric.Point(10, 0),39        intersection = fabric.Intersection.intersectLineLine(p1, p2, p3, p4);40    assert.ok(typeof fabric.Intersection.intersectLineLine === 'function', 'has intersectLineLine function');41    assert.ok(intersection instanceof fabric.Intersection, 'returns a fabric.Intersection');42    assert.equal(intersection.status, 'Intersection', 'it return a inteserction result');43    assert.deepEqual(intersection.points[0], new fabric.Point(5, 5), 'intersect in 5,5');44  });45  QUnit.test('intersectLineLine parallel', function(assert) {46    var p1 = new fabric.Point(0, 0), p2 = new fabric.Point(0,10),47        p3 = new fabric.Point(10, 0), p4 = new fabric.Point(10, 10),48        intersection = fabric.Intersection.intersectLineLine(p1, p2, p3, p4);49    assert.ok(intersection instanceof fabric.Intersection, 'returns a fabric.Intersection');50    assert.equal(intersection.status, 'Parallel', 'it return a Parallel result');51    assert.deepEqual(intersection.points, [], 'no point of intersections');52  });53  QUnit.test('intersectLineLine coincident', function(assert) {54    var p1 = new fabric.Point(0, 0), p2 = new fabric.Point(0, 10),55        p3 = new fabric.Point(0, 0), p4 = new fabric.Point(0, 10),56        intersection = fabric.Intersection.intersectLineLine(p1, p2, p3, p4);57    assert.ok(intersection instanceof fabric.Intersection, 'returns a fabric.Intersection');58    assert.equal(intersection.status, 'Coincident', 'it return a Coincident result');59    assert.deepEqual(intersection.points, [], 'no point of intersections');60  });61  QUnit.test('intersectLineLine coincident but different', function(assert) {62    var p1 = new fabric.Point(0, 0), p2 = new fabric.Point(0, 10),63        p3 = new fabric.Point(0, 1), p4 = new fabric.Point(0, 9),64        intersection = fabric.Intersection.intersectLineLine(p1, p2, p3, p4);65    assert.ok(intersection instanceof fabric.Intersection, 'returns a fabric.Intersection');66    assert.equal(intersection.status, 'Coincident', 'it return a Coincident result');67    assert.deepEqual(intersection.points, [], 'no point of intersections');68  });69  QUnit.test('intersectLineLine no intersect', function(assert) {70    var p1 = new fabric.Point(0, 0), p2 = new fabric.Point(0,10),71        p3 = new fabric.Point(10, 0), p4 = new fabric.Point(1, 10),72        intersection = fabric.Intersection.intersectLineLine(p1, p2, p3, p4);73    assert.ok(intersection instanceof fabric.Intersection, 'returns a fabric.Intersection');74    assert.equal(intersection.status, undefined, 'it return a undefined status result');75    assert.deepEqual(intersection.points, [], 'no point of intersections');76  });77  QUnit.test('intersectLinePolygon', function(assert) {78    var p1 = new fabric.Point(0, 5), p2 = new fabric.Point(10, 5),79        p3 = new fabric.Point(5, 0), p4 = new fabric.Point(2, 10),80        p5 = new fabric.Point(8, 10), points = [p3, p4, p5],81        intersection = fabric.Intersection.intersectLinePolygon(p1, p2, points);82    assert.ok(intersection instanceof fabric.Intersection, 'returns a fabric.Intersection');83    assert.ok(typeof fabric.Intersection.intersectLinePolygon === 'function', 'has intersectLinePolygon function');84    assert.equal(intersection.status, 'Intersection', 'it return a Intersection result');85    assert.equal(intersection.points.length, 2, '2 points of intersections');86    assert.deepEqual(intersection.points[0], new fabric.Point(3.5, 5), 'intersect in 3.5 ,5');87    assert.deepEqual(intersection.points[1], new fabric.Point(6.5, 5), 'intersect in 6.5 ,5');88  });89  QUnit.test('intersectLinePolygon in one point', function(assert) {90    var p1 = new fabric.Point(0, 5), p2 = new fabric.Point(5, 5),91        p3 = new fabric.Point(5, 0), p4 = new fabric.Point(2, 10),92        p5 = new fabric.Point(8, 10), points = [p3, p4, p5],93        intersection = fabric.Intersection.intersectLinePolygon(p1, p2, points);94    assert.ok(intersection instanceof fabric.Intersection, 'returns a fabric.Intersection');95    assert.equal(intersection.status, 'Intersection', 'it return a Intersection result');96    assert.equal(intersection.points.length, 1, '1 points of intersections');97    assert.deepEqual(intersection.points[0], new fabric.Point(3.5, 5), 'intersect in 3.5 ,5');98  });99  QUnit.test('intersectLinePolygon in one point', function(assert) {100    var p1 = new fabric.Point(0, 5), p2 = new fabric.Point(3, 5),101        p3 = new fabric.Point(5, 0), p4 = new fabric.Point(2, 10),102        p5 = new fabric.Point(8, 10), points = [p3, p4, p5],103        intersection = fabric.Intersection.intersectLinePolygon(p1, p2, points);104    assert.ok(intersection instanceof fabric.Intersection, 'returns a fabric.Intersection');105    assert.equal(intersection.status, undefined, 'it return a undefined result');106    assert.equal(intersection.points.length, 0, '0 points of intersections');107  });108  QUnit.test('intersectLinePolygon on a polygon segment', function(assert) {109    //TODO: fix this. it should return coincident.110    var p1 = new fabric.Point(1, 10), p2 = new fabric.Point(9, 10),111        p3 = new fabric.Point(5, 0), p4 = new fabric.Point(2, 10),112        p5 = new fabric.Point(8, 10), points = [p3, p4, p5],113        intersection = fabric.Intersection.intersectLinePolygon(p1, p2, points);114    assert.ok(intersection instanceof fabric.Intersection, 'returns a fabric.Intersection');115    assert.equal(intersection.status, 'Intersection', 'it return a Intersection result');116    assert.equal(intersection.points.length, 2, '2 points of intersections');117    assert.deepEqual(intersection.points[0], new fabric.Point(2, 10), 'intersect in 2, 10');118    assert.deepEqual(intersection.points[1], new fabric.Point(8, 10), 'intersect in 8, 10');119  });120  QUnit.test('intersectPolygonPolygon not intersecting', function(assert) {121    var p3b = new fabric.Point(50, 0), p4b = new fabric.Point(20, 100),122        p5b = new fabric.Point(80, 100), pointsb = [p3b, p4b, p5b],123        p3 = new fabric.Point(5, 0), p4 = new fabric.Point(2, 10),124        p5 = new fabric.Point(8, 10), points = [p3, p4, p5],125        intersection = fabric.Intersection.intersectPolygonPolygon(pointsb, points);126    assert.ok(typeof fabric.Intersection.intersectPolygonPolygon === 'function', 'has intersectPolygonPolygon function');127    assert.ok(intersection instanceof fabric.Intersection, 'returns a fabric.Intersection');128    assert.equal(intersection.status, undefined, 'it return a Intersection with no status');129    assert.equal(intersection.points.length, 0, '0 points of intersections');130  });131  QUnit.test('intersectPolygonPolygon intersecting', function(assert) {132    var p3b = new fabric.Point(1, 1), p4b = new fabric.Point(3, 1),133        p5b = new fabric.Point(3, 3), p6b = new fabric.Point(1, 3),134        pointsb = [p3b, p4b, p5b, p6b],135        p3 = new fabric.Point(2, 2), p4 = new fabric.Point(4, 2),136        p5 = new fabric.Point(4, 4), p6 = new fabric.Point(2, 4),137        points = [p3, p4, p5, p6],138        intersection = fabric.Intersection.intersectPolygonPolygon(pointsb, points);139    assert.ok(typeof fabric.Intersection.intersectPolygonPolygon === 'function', 'has intersectPolygonPolygon function');140    assert.ok(intersection instanceof fabric.Intersection, 'returns a fabric.Intersection');141    assert.equal(intersection.status, 'Intersection', 'it return a Intersection result');142    assert.equal(intersection.points.length, 2, '2 points of intersections');143    assert.deepEqual(intersection.points[0], new fabric.Point(3, 2), 'point of intersections 3, 2');144    assert.deepEqual(intersection.points[1], new fabric.Point(2, 3), 'point of intersections 2, 3');145  });146  QUnit.test('intersectPolygonRectangle intersecting', function(assert) {147    var p3b = new fabric.Point(1, 1),148        p5b = new fabric.Point(3, 3),149        p3 = new fabric.Point(2, 2), p4 = new fabric.Point(4, 2),150        p5 = new fabric.Point(4, 4), p6 = new fabric.Point(2, 4),151        points = [p3, p4, p5, p6],152        intersection = fabric.Intersection.intersectPolygonRectangle(points, p3b, p5b);153    assert.ok(typeof fabric.Intersection.intersectPolygonRectangle === 'function', 'has intersectPolygonPolygon function');154    assert.ok(intersection instanceof fabric.Intersection, 'returns a fabric.Intersection');155    assert.equal(intersection.status, 'Intersection', 'it return a Intersection result');156    assert.equal(intersection.points.length, 2, '2 points of intersections');157    assert.deepEqual(intersection.points[0], new fabric.Point(3, 2), 'point of intersections 3, 2');158    assert.deepEqual(intersection.points[1], new fabric.Point(2, 3), 'point of intersections 2, 3');159  });160  QUnit.test('intersectPolygonRectangle not intersecting', function(assert) {161    var p3b = new fabric.Point(10, 10),162        p5b = new fabric.Point(30, 30),163        p3 = new fabric.Point(2, 2), p4 = new fabric.Point(4, 2),164        p5 = new fabric.Point(4, 4), p6 = new fabric.Point(2, 4),165        points = [p3, p4, p5, p6],166        intersection = fabric.Intersection.intersectPolygonRectangle(points, p3b, p5b);167    assert.ok(typeof fabric.Intersection.intersectPolygonRectangle === 'function', 'has intersectPolygonPolygon function');168    assert.ok(intersection instanceof fabric.Intersection, 'returns a fabric.Intersection');169    assert.equal(intersection.status, undefined, 'it return a Intersection result');170    assert.equal(intersection.points.length, 0, '0 points of intersections');171  });...

IntersectionAdder.js

Source:IntersectionAdder.js

1/* Copyright (c) 2011 by The Authors.2 * Published under the LGPL 2.1 license.3 * See /license-notice.txt for the full text of the license notice.4 * See /license.txt for the full text of the license.5 */6/**7 *@requires jsts/noding/SegmentIntersector.js8 */9/**10 * Computes the intersections between two line segments in {@link SegmentString}s11 * and adds them to each string. The {@link SegmentIntersector} is passed to a12 * {@link Noder}. The {@link addIntersections} method is called whenever the13 * {@link Noder} detects that two SegmentStrings <i>might</i> intersect. This14 * class is an example of the <i>Strategy</i> pattern.15 *16 * @constructor17 */18jsts.noding.IntersectionAdder = function(li) {19  this.li = li;20};21jsts.noding.IntersectionAdder.prototype = new jsts.noding.SegmentIntersector();22jsts.noding.IntersectionAdder.constructor = jsts.noding.IntersectionAdder;23jsts.noding.IntersectionAdder.isAdjacentSegments = function(i1, i2) {24  return Math.abs(i1 - i2) === 1;25};26/**27 * These variables keep track of what types of intersections were found during28 * ALL edges that have been intersected.29 */30/**31 * @type {boolean}32 * @private33 */34jsts.noding.IntersectionAdder.prototype._hasIntersection = false;35/**36 * @type {boolean}37 * @private38 */39jsts.noding.IntersectionAdder.prototype.hasProper = false;40/**41 * @type {boolean}42 * @private43 */44jsts.noding.IntersectionAdder.prototype.hasProperInterior = false;45/**46 * @type {boolean}47 * @private48 */49jsts.noding.IntersectionAdder.prototype.hasInterior = false;50// the proper intersection point found51/**52 * @type {Coordinate}53 * @private54 */55jsts.noding.IntersectionAdder.prototype.properIntersectionPoint = null;56/**57 * @type {LineIntersector}58 * @private59 */60jsts.noding.IntersectionAdder.prototype.li = null;61/**62 * @type {boolean}63 * @private64 */65jsts.noding.IntersectionAdder.prototype.isSelfIntersection = null;66jsts.noding.IntersectionAdder.prototype.numIntersections = 0;67jsts.noding.IntersectionAdder.prototype.numInteriorIntersections = 0;68jsts.noding.IntersectionAdder.prototype.numProperIntersections = 0;69// testing only70jsts.noding.IntersectionAdder.prototype.numTests = 0;71jsts.noding.IntersectionAdder.prototype.getLineIntersector = function() {72  return this.li;73};74/**75 * @return the proper intersection point, or <code>null</code> if none was76 *         found.77 */78jsts.noding.IntersectionAdder.prototype.getProperIntersectionPoint = function() {79  return this.properIntersectionPoint;80};81jsts.noding.IntersectionAdder.prototype.hasIntersection = function() {82  return this._hasIntersection;83};84/**85 * A proper intersection is an intersection which is interior to at least two86 * line segments. Note that a proper intersection is not necessarily in the87 * interior of the entire Geometry, since another edge may have an endpoint88 * equal to the intersection, which according to SFS semantics can result in the89 * point being on the Boundary of the Geometry.90 */91jsts.noding.IntersectionAdder.prototype.hasProperIntersection = function() {92  return this.hasProper;93};94/**95 * A proper interior intersection is a proper intersection which is <b>not</b>96 * contained in the set of boundary nodes set for this SegmentIntersector.97 */98jsts.noding.IntersectionAdder.prototype.hasProperInteriorIntersection = function() {99  return this.hasProperInterior;100};101/**102 * An interior intersection is an intersection which is in the interior of some103 * segment.104 */105jsts.noding.IntersectionAdder.prototype.hasInteriorIntersection = function() {106  return this.hasInterior;107};108/**109 * A trivial intersection is an apparent self-intersection which in fact is110 * simply the point shared by adjacent line segments. Note that closed edges111 * require a special check for the point shared by the beginning and end112 * segments.113 *114 * @private115 */116jsts.noding.IntersectionAdder.prototype.isTrivialIntersection = function(e0,117    segIndex0, e1, segIndex1) {118  if (e0 == e1) {119    if (this.li.getIntersectionNum() == 1) {120      if (jsts.noding.IntersectionAdder121          .isAdjacentSegments(segIndex0, segIndex1))122        return true;123      if (e0.isClosed()) {124        var maxSegIndex = e0.size() - 1;125        if ((segIndex0 === 0 && segIndex1 === maxSegIndex) ||126            (segIndex1 === 0 && segIndex0 === maxSegIndex)) {127          return true;128        }129      }130    }131  }132  return false;133};134/**135 * This method is called by clients of the {@link SegmentIntersector} class to136 * process intersections for two segments of the {@link SegmentString}s being137 * intersected. Note that some clients (such as {@link MonotoneChain}s) may138 * optimize away this call for segment pairs which they have determined do not139 * intersect (e.g. by an disjoint envelope test).140 */141jsts.noding.IntersectionAdder.prototype.processIntersections = function(e0,142    segIndex0, e1, segIndex1) {143  if (e0 === e1 && segIndex0 === segIndex1)144    return;145  this.numTests++;146  var p00 = e0.getCoordinates()[segIndex0];147  var p01 = e0.getCoordinates()[segIndex0 + 1];148  var p10 = e1.getCoordinates()[segIndex1];149  var p11 = e1.getCoordinates()[segIndex1 + 1];150  this.li.computeIntersection(p00, p01, p10, p11);151  if (this.li.hasIntersection()) {152    this.numIntersections++;153    if (this.li.isInteriorIntersection()) {154      this.numInteriorIntersections++;155      this.hasInterior = true;156    }157    // if the segments are adjacent they have at least one trivial intersection,158    // the shared endpoint. Don't bother adding it if it is the159    // only intersection.160    if (!this.isTrivialIntersection(e0, segIndex0, e1, segIndex1)) {161      this._hasIntersection = true;162      e0.addIntersections(this.li, segIndex0, 0);163      e1.addIntersections(this.li, segIndex1, 1);164      if (this.li.isProper()) {165        this.numProperIntersections++;166        this.hasProper = true;167        this.hasProperInterior = true;168      }169    }170  }171};172/**173 * Always process all intersections174 *175 * @return false always.176 */177jsts.noding.IntersectionAdder.prototype.isDone = function() {178  return false;...

Using AI Code Generation

1const { intersection } = require('storybook-root');2const a = [1, 2, 3, 4, 5];3const b = [3, 4, 5, 6, 7];4const { intersection } = require('storybook-root');5const a = [1, 2, 3, 4, 5];6const b = [3, 4, 5, 6, 7];7const { intersection } = require('storybook-root');8const a = [1, 2, 3, 4, 5];9const b = [3, 4, 5, 6, 7];10const { intersection } = require('storybook-root');11const a = [1, 2, 3, 4, 5];12const b = [3, 4, 5, 6, 7];13const { intersection } = require('storybook-root');14const a = [1, 2, 3, 4, 5];15const b = [3, 4, 5, 6, 7];16const { intersection } = require('storybook-root');17const a = [1, 2, 3, 4, 5];18const b = [3, 4, 5, 6, 7];19const { intersection } = require('storybook-root');20const a = [1, 2, 3, 4, 5];

Using AI Code Generation

1import { intersection } from 'storybook-root';2import { intersection } from 'storybook-root';3import { intersection } from 'storybook-root';4import { intersection } from 'storybook-root';5import { intersection } from 'storybook-root';6import { intersection } from 'storybook-root';7import { intersection } from 'storybook-root';8import { intersection } from 'storybook-root';9import { intersection } from 'storybook-root';10import { intersection } from 'storybook-root';11import { intersection } from 'storybook-root';12import { intersection } from 'storybook-root';13import { intersection } from 'storybook-root';14import { intersection } from 'storybook-root';15import { intersection } from 'storybook-root';16import { intersection } from 'storybook-root';17import { intersection } from 'storybook-root';18import { intersection } from 'storybook-root';19import { intersection } from 'storybook-root';20import { intersection } from 'storybook-root';21import { intersection } from 'storybook-root';22import { intersection } from 'storybook-root';

Using AI Code Generation

1import { intersection } from "storybook-root";2import { intersection } from "storybook-root";3import { intersection } from "storybook-root";4import { intersection } from "storybook-root";5import { intersection } from "storybook-root";6import { intersection } from "storybook-root";7import { intersection } from "storybook-root";8import { intersection } from "storybook-root";9import { intersection } from "storybook-root";10import { intersection } from "storybook-root";

Using AI Code Generation

1import { intersection } from 'storybook-root/.storybook/utils';2import { intersection } from 'storybook-root/src/.storybook/utils';3import { intersection } from 'storybook-root/src/utils';4import { intersection } from 'storybook-root/src/utils';5import { intersection } from 'storybook-root/src/utils';6import { intersection } from 'storybook-root/src/utils';7import { intersection } from 'storybook-root/src/utils';8import { intersection } from 'storybook-root/src/utils';9import { intersection } from 'storybook-root/src/utils';10import { intersection } from 'storybook-root/src/utils';11import { intersection } from 'storybook-root/src/utils';12import { intersection } from 'storybook-root/src/utils';13import { intersection } from 'storybook-root/src/utils';14import { intersection } from 'storybook-root/src/utils';15import { intersection } from 'storybook-root/src/utils';16import { intersection } from 'storybook-root/src/utils';17import { intersection } from 'storybook-root/src/utils';18import { intersection } from 'storybook-root/src/utils';19import { intersection } from 'storybook-root/src/utils';20import { intersection } from 'storybook-root/src/utils';

Using AI Code Generation

1import { intersection } from 'storybook-root';2console.log(intersection([1, 2], [2, 3]));3export { intersection } from './utils';4export const intersection = (arr1, arr2) => {5  return arr1.filter((item) => arr2.includes(item));6};7export const intersection = (arr1, arr2) => {8  return arr1.filter((item) => arr2.includes(item));9};10export const intersection = (arr1, arr2) => {11  return arr1.filter((item) => arr2.includes(item));12};13export const intersection = (arr1, arr2) => {14  return arr1.filter((item) => arr2.includes(item));15};16export const intersection = (arr1, arr2) => {17  return arr1.filter((item) => arr2.includes(item));18};19export const intersection = (arr1, arr2) => {20  return arr1.filter((item) => arr2.includes(item));21};22export const intersection = (arr1, arr2) => {23  return arr1.filter((item) => arr2.includes(item));24};25export const intersection = (arr1, arr2) => {26  return arr1.filter((item) => arr2.includes(item));27};28export const intersection = (arr1, arr2) => {29  return arr1.filter((item) => arr2.includes(item));30};31export const intersection = (arr1, arr2) => {32  return arr1.filter((item) => arr2.includes(item));33};34export const intersection = (arr1, arr2) => {

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.