Can someone explain the purpose and provide an example usage for myFunctionParam argument in the namespaced plugin?

The link "Non Widget-factory widget" on your documentation page "https://github.com/jquery-boilerplate/jquery-patterns" leads to a 404 page not found. This is the linked url:

• https://github.com/jquery-boilerplate/jquery-patterns/blob/master/patterns/jquery.simplewidget.plugin-boilerplate.js%5D

The page (=your example) doesn't exist any more. Would be interested to see this lightweight alternative to jQuery UI widget factory.

Should we use it on these patterns?

https://github.com/Akkuma/jquery-pluginfy an example of it in use is https://github.com/Akkuma/steam-store/blob/gh-pages/scripts/jquery.scroller.js

Is it a good practice to break the second plugin instance if we call it like this?

$(selector).defaultPluginName({
    start: 13,
    end: 37
}).defaultPluginName({
    start: 37,
    end: 42
});

It will not work since we allow the plugin only to be instantiated once per element. But to remove the if statement in our plugin definition is even not the best idea, or?

Extend pattern: Extended options link is DEAD!

Why not exending the documentation at hand with a style manifesto just like here:
https://github.com/ieservices/idiomatic.js ?

Well, I started to add two examples in my fork. You can pull it. I'll send you a pull request.

It would be too hard if i say, that i hate @DiegoLopesLima's pull request, however instead of replacing the old one it is might the better choice to add a new one ;-)

Just chiming in here, going to post some thoughts later today.

If we publish any notification based on some click event then that event is not sub scribed. if you invoke the below method based on some button click event then it does not perform the actions in subscribe event.

$("#testPlugin").testSubscribe().trigger("eventPublished");

But if we perform the below step on page load then it works.

$("#testPlugin").testSubscribe();
$("#testPlugin").testSubscribe().trigger("eventPublished");

Hi, could someone explain where I am going wrong. I'm trying to use the jQuery boilerplate but having trouble when adding functions and calling them:

/*!
 * jQuery lightweight plugin boilerplate
 * Original author: @ajpiano
 * Further changes, comments: @addyosmani
 * Licensed under the MIT license
 */

// the semi-colon before the function invocation is a safety
// net against concatenated scripts and/or other plugins
// that are not closed properly.
;(function ( $, window, document, undefined ) {

    // undefined is used here as the undefined global
    // variable in ECMAScript 3 and is mutable (i.e. it can
    // be changed by someone else). undefined isn't really
    // being passed in so we can ensure that its value is
    // truly undefined. In ES5, undefined can no longer be
    // modified.

    // window and document are passed through as local
    // variables rather than as globals, because this (slightly)
    // quickens the resolution process and can be more
    // efficiently minified (especially when both are
    // regularly referenced in your plugin).

    // Create the defaults once
    var pluginName = "defaultPluginName",
        defaults = {
            propertyName: "value"
        };

    // The actual plugin constructor
    function Plugin( element, options ) {
        this.element = element;

        // jQuery has an extend method that merges the
        // contents of two or more objects, storing the
        // result in the first object. The first object
        // is generally empty because we don't want to alter
        // the default options for future instances of the plugin
        this.options = $.extend( {}, defaults, options) ;

        this._defaults = defaults;
        this._name = pluginName;

        this.init();
    }

    Plugin.prototype = {
        
        init: function() {
            // Place initialization logic here
            // You already have access to the DOM element and
            // the options via the instance, e.g. this.element
            // and this.options
            // you can add more functions like the one below and 
            // call them like so: this.yourOtherFunction(this.element, this.options).

            $(this.element).each(function() {
                console.log('Main function');

                this.functionOne(this.element, this.options);
            });
        }, 

        functionOne: function(el, options) {
            console.log('functionOne');
            
            this.functionTwo(el, options);
        },

        functionTwo: function(el, options) {
            console.log('functionTwo');
        }
    };

    // A really lightweight plugin wrapper around the constructor,
    // preventing against multiple instantiations
    $.fn[pluginName] = function ( options ) {
        return this.each(function () {
            if (!$.data(this, 'plugin_' + pluginName)) {
                $.data(this, 'plugin_' + pluginName,
                new Plugin( this, options ));
            }
        });
    }

})( jQuery, window, document );

This simple calling of functions results in the following console log:

Main function

TypeError: this.functionOne is not a function
this.functionOne(this.element, this.options);

Did I miss something? Reading the comments in the script, I think I'm calling the functions correctly?

Thanks!

Hi,

I was hoping this template could be updated so that it can support the ability to be called as $. defaultPluginName() so it can return a value (string, object, boolean) along with $(selector).defaultPluginName() so it can return a chain able object.

I'm actually trying to figure out how it's done and so for unsuccessful. I'll continue to look up how it's done to go along with this boilerplate.

I was about to apply your basic plugin boilerplate to my plugins as I think in general it's neater than what I've been doing, but there is one thing I don't like; namely that the defaults are not exposed publically so that a developer can change the default settings for the plugin (eg if a plugin defaults to autoplay: false, but on the developer's site most instances use autoplay:true it makes sense for them to over-ride the default globally). Of course, the developer coudl go in and directly edit the plugin, but I never like doing this as it's not obvious to future developers that they can't just overwrite the plugin with updated versions from the plutgin's author.

I think this would need to be done by getting rid of the defaults variable and using $.fn[pluginName].defaults instead.