capsulable - npm Package Compare versions

Comparing version 1.0.0 to 1.1.0

index.js

@@ -39,5 +39,7 @@ const Field = require('./src/initialize')
     // Configure encapsulated class.
-    return Capsulable(Origin, Field())
+    let mode = undefined
+    if(typeof inherit == 'string') mode = inherit
+    return Capsulable(Origin, Field(), mode)
 }
 
 module.exports = Capsulator

package.json

 {
   "name": "capsulable",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "A module that helps developers easily encapsulate classes in nodejs.",
@@ -5,0 +5,0 @@ "main": "index.js",

README-KR.md

@@ -10,3 +10,3 @@ ## Capsulable
 
-캡슐러블 모듈은 자바스크립트 클래스에서 쉽게 접근제한자 개념을 사용할 수 있게 돕습니다. 클로저 변수 개념을 통해 캡슐화 및 은닉화 개념을 구현합니다.
+캡슐러블 모듈은 자바스크립트 클래스에서 쉽게 접근제한자 개념을 사용할 수 있게 돕습니다. 클로저 개념을 통해 캡슐화 및 은닉화 개념을 구현합니다.
 
@@ -33,3 +33,3 @@ ## 설치방법
 
-Capsulable 은 `class` 의 `constructor` 함수를 통해서 데이터 필드를 공유합니다. (이는 즉 Capsulable 이 최종적으로 항상 자식 클래스로 구성 됨을 의미합니다.) 캡슐화 하길 원하는 클래스는 사전에 Capsulable 을 통해서 coonstructr 에서 데이터 필드를 상속 받아야합니다. 예시 상 문법은 ES5로 표기되나, Babel을 통한 ES6 문법으로 구현해도 됩니다.
+Capsulable 은 `class` 의 `constructor` 함수를 통해서 데이터 필드를 공유합니다. (이는 즉 Capsulable 이 최종적으로 항상 자식 클래스로 구성 됨을 의미합니다.) 캡슐화 하길 원하는 클래스는 사전에 Capsulable 을 통해서 constructor 에서 데이터 필드를 상속 받아야합니다. 예시 상 문법은 ES5로 표기되나, Babel을 통한 ES6 문법으로 구현해도 됩니다.
 
@@ -274,2 +274,22 @@ ### 클래스 정의 예제
 
+## Final Class 구현
+
+클래스 원형의 캡슐화 이후 파생 클래스를 더 이상 만들길 원치 않는 경우 Capsulable 함수 사용시 2번째 인자로 final 모드를 적용시킴으로써 파생 클래스와 데이터 필드를 공유하지 않도록 할 수 있습니다. (클래스의 파생을 완전히 막지는 못하나, 데이터 필드가 공유되는 것을 막을 수는 있습니다.)
+
+```js
+// index.js
+const Capsulable = require('./capsulable')
+const A = require('./A')
+
+// 2번째 인자로 final을 적으면
+// 파생클래스와 데이터 필드를 공유하지 않습니다.
+const SharedA = Capsulable(A, 'final')
+
+// 캡슐화 된 클래스를 통해서
+// 인스턴스를 생성할 수 있습니다.
+let sharedA = new SharedA()
+```
+
+--------------------------------------
+
 ## 작업 목록
@@ -288,5 +308,6 @@
 - [x] assert 가변모듈화 하여 종속성 완전 배제 구현
+- [x] final 클래스 구현
+- [ ] final 변수 구현
 - [ ] 캡슐화 된 클래스의 constructor 가변변수 인자 구현
 - [ ] 캡슐화 된 클래스의 constructor 가변변수의 파생클래스 공유 구현
-- [ ] final 키워드 기능 구현
 --------------------------------------
@@ -293,0 +314,0 @@

README.md

@@ -11,3 +11,3 @@ ## Capsulable
 
-Encapsulated modules help you use the concept of access limiting in JavaScript classes. Implement the concepts of encapsulation and concealment through the concept of closure variables.
+Encapsulated modules help you use the concept of access limiting in JavaScript classes. Implement the concepts of encapsulation and concealment through the concept of closure.
 
@@ -37,3 +37,3 @@
 
-Capable shares the data field through the `constructor` function of `class`. (This means that the Capable is ultimately always composed of child classes.) Classes that want to be encapsulated must inherit the data fields from the Coonstructr through the Capsulable in advance. Examples of grammar are marked as ES5, but can be implemented using ES6 via the Babel.
+Capable shares the data field through the `constructor` function of `class`. (This means that the Capable is ultimately always composed of child classes.) Classes that want to be encapsulated must inherit the data fields from the constructor through the Capsulable in advance. Examples of grammar are marked as ES5, but can be implemented using ES6 via the Babel.
 
@@ -273,2 +273,21 @@ ### Example of class definition
 
+## Implement Final Class
+
+If you no longer want to create a derived class after the encapsulation of a class prototype, you can use the Capsulable function to apply final mode as a second factor to avoid sharing derived classes and data fields. (This does not completely block a class from being derived, but can prevent data fields from being shared.)
+
+```js
+// index.js
+const Capsulable = require('./capsulable')
+const A = require('./A')
+
+// If you write final in the second parameter,
+// the derived class and the data fields are not shared.
+const SharedA = Capsulable(A, 'final')
+
+// Can create instances through encapsulated classes.
+let sharedA = new SharedA()
+```
+
+--------------------------------------
+
 ## Worklist
@@ -287,5 +306,6 @@
 - [x] Implement complete exclusion of dependencies by modularizing asset
+- [x] Implement final class
+- [ ] Implement final variable
 - [ ] Implementing the constructor variable variable factor of the encapsulated class
 - [ ] Implementing derivative class sharing with constructor variable of encapsulated class
-- [ ] Implement final keyword function
 --------------------------------------
@@ -292,0 +312,0 @@

src/capsulable.js

@@ -7,3 +7,3 @@ /**
  */
-module.exports = (Origin, Protect)=>{
+module.exports = (Origin, Protect, mode)=>{
     return class Capsulable extends Origin {
@@ -13,2 +13,10 @@ constructor(inherit){
             super(Field)
+
+            // When in final mode,
+            // the data field is
+            // not passed to the child class.
+            if(typeof mode == 'string'
+                && mode.toLowerCase() == 'final')
+                return
+
             if(typeof inherit === 'object')
@@ -15,0 +23,0 @@ if(new.target != this.constructor.name)

test/class/test.js

@@ -79,2 +79,16 @@ const assert  = require('assert')
     UnitTest(packB, packC)
+
+
+    // Final mode Test
+    let FinalClass = Capsulable(A, 'final')
+    class FailureClass extends FinalClass{
+        constructor(inherit){
+            let hook = {}
+            super(hook)
+            assert(typeof hook['field'] === 'undefined')
+            // Field(this, hook.field)
+            // if(inherit) Capsulable(hook, inherit)
+        }
+    }
+    new FailureClass()
 }

No alert changes

Improved metrics

Total package byte prevSize

50012

increased by1.37%

Number of lines in readme file

312

increased by6.85%

Worsened metrics

Number of package files

25

decreased by-3.85%

Lines of code

774

decreased by-5.15%

No dependency changes