The with keyword is a helpful tool for creating scope, but it also comes with some limitations (and is actually forbidden in strict mode).

When using the with keyword, you can establish a private variable called privateScope within your module to store all of your private methods:

var myModule = function () {

    var privateConfigVar = "Private!";
    var privateScope = {};

    //"constructor"
    function module() {}

    var proto = module.prototype; //avoids multiple attribute lookup

    //Let's redefine your example's private method, but with a new approach
    privateScope['privateMethod1'] = function() {
        console.log('private');
    }

    proto.publicMethod = function () {
        with(privateScope) {
            //this call should work
            privateMethod1();
        }
        console.log('public');
    }

    proto.publicMethod2 = function(name, fn) {
        with(privateScope) {
            //this will be defined later by a Mixin
            otherPrivateMethod();
        }
        console.log('public2');
    }

    proto.definePrivateFunction = function(name, fn) {
        privateScope[name] = fn;
    }

    return module;
}

Your mixin can utilize the definePrivateFunction method we just created to add private methods to the private scope:

//An example implementation of a mixin
function Mixin(source, target, flag) {
    if (flag === "private") {
        for (var currentMethodName in source) {
            target.definePrivateFunction(currentMethodName, source[currentMethod])
        }
    } else {
        for (var currentMethodName in source) {
            target[currentMethodName] = source[currentMethod];
        }
    }
}

The following code should run smoothly:

var test = myModule();
var testInstance = new test();
testInstance.publicMethod(); // will invoke the internally defined private method

Mixin({
          otherPrivateMethod: function() {
              console.log("other Private Method called")
          }
      }, test.prototype, "private");

testInstance.publicMethod2(); // will call the private method added by the mixin

In an ideal scenario, I would like to incorporate methods from other objects as private and public methods in my code. This way, I could use an "extend" function with a parameter specifying if the method should be private or public.

However, it has been pointed out that achieving this exact goal is not possible.

So, having some methods available within a module by simply calling them directly, while ensuring correct scope, and others available through explicit module reference and maintaining proper scope.

When discussing the concept of 'scope,' it refers to a closed address space defined by functions. Except for closures, scope is confined to a function's runtime and cannot be tampered with or manipulated.

The term that fits better in this context is 'context.' JavaScript relies on late binding and two types of delegation – automatic delegation via prototype chain traversal or explicit delegation using either the 'call' or 'apply' methods provided by every function object.

JavaScript inherently offers a function-based Mixin pattern that surpasses traditional extend or mixin implementations by providing free delegation and the ability to pass around state, which many other helpers lack without additional workarounds.

Bergi earned bounties for his insightful explanation regarding delegation in JavaScript. In his answer, there is a link to my resources, although they have become outdated since the referenced talk. Unfortunately, due to insufficient reputation points, I can't comment directly on his answer. Therefore, I'm directing attention to the current state of my research and understanding of JavaScript's capabilities in generalizing programming approaches involving Traits and Mixins.

Returning to the original question, let's modify the provided code examples from modules and mixins to a basic constructor function and what I might call a "proxified" or "bicontextual" mixin. This approach showcases a pure function-based mixin pattern that aligns closely with the intended goal.

var MyBicontextualMixin = function(localProxy) {

  localProxy.proxifiedAccessible = function() {
    console.log("proxified accessible.");
  };
  this.publiclyAccessible = function() {
    console.log("publicly accessible.");
  };
};

var MyConstructor = function() {
  var localProxy = {};
  MyBicontextualMixin.call(this, localProxy);

  var locallyAccessible = localProxy.proxifiedAccessible;

  // invoking methods
  locallyAccessible();        // "proxified accessible."
  this.publiclyAccessible();  // "publicly accessible."
};

(new MyConstructor);

// output:
//
// proxified accessible.
// publicly accessible.

This particular pattern forms the basis for composing function-based Traits that utilize conflict resolution mechanisms of "proxified" Mixins without exposing this functionality publicly.

To illustrate a practical example, let's create a reusable Queue module by combining various mixins following the DRY principle. This example addresses the encapsulation and exposure requirements solely based on the module pattern and function-based mixin composition.

// JavaScript code examples go here...

.as-console-wrapper { max-height: 100%!important; top: 0; }